Debian Codegraph @

Source/Reasoner/Preprocess/CTriggeredImplicationBinaryAbsorberPreProcess.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CTriggeredImplicationBinaryAbsorberPreProcess.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Preprocess {
29
30
31 #ifdef KONCLUDE_FORCE_ALL_DEBUG_DEACTIVATED
32 #define KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(a)
33 #else
34 //#define KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(a) a
35 #define KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(a)
36 #endif
37
38
39
40 CTriggeredImplicationBinaryAbsorberPreProcess::CTriggeredImplicationBinaryAbsorberPreProcess() {
41 mConfRequiresExistingInverseRole = false;
42 mConfAbsorbEqClassDefinitions = true;
43 mConfAbsorbDisjunctions = true;
44 mConfAbsorbSimpleDisjunctions = true;
45 mConfPartialGCIAbsorption = true;
46 mConfPartialAbsorbEqClassDefinitions = true;
47 mConfPartialDisjunctionsAbsorption = true;
48 mConfOnlyPositiveDisjunctionsAbsorption = true;
49 mConfNominalSchemaPathPreabsorption = true;
50 mConfNominalSchemaBackPropagation = true;
51 mConfNominalSchemaBackPropagationMultiTrigger = true;
52 mConfImplicationsForTriggerReusue = true;
53
54 mConfOftenTriggerUseCountPunishment = 20;
55 mConfPunishOftenSameTriggerUse = true;
56 mConfDatatypeAbsorption = true;
57
58 mConfCardinalityQualificationTriggerAbsorption = true;
59 mConfPartialCardinalityQualificationTriggerAbsorption = true;
60 mConfOnlyPositiveCardinalityQualificationTriggerAbsorption = false;
61
62 mConfGlobalNegatedSelfRestrictionsToRoleDomainAbsorption = true;
63
64 mLastDisjunctId = 0;
65 mOnto = nullptr;
66 }
67
68
69 CTriggeredImplicationBinaryAbsorberPreProcess::~CTriggeredImplicationBinaryAbsorberPreProcess() {
70 qDeleteAll(mTriggerContainer);
71 mTriggerContainer.clear();
72 }
73
74
75 CConcreteOntology *CTriggeredImplicationBinaryAbsorberPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) {
76 CMBox *mBox = ontology->getDataBoxes()->getMBox();
77 CTBox *tBox = ontology->getDataBoxes()->getTBox();
78 CRBox *rBox = ontology->getDataBoxes()->getRBox();
79 CABox *aBox = ontology->getDataBoxes()->getABox();
80 mMBox = mBox;
81 mTBox = tBox;
82
83 mTmpTriggerLinker = nullptr;
84 mLastDisjunctId = 0;
85
86 mConceptVec = tBox->getConceptVector();
87 cint64 conceptCount = mConceptVec->getItemCount();
88
89 CRoleVector *roles = rBox->getRoleVector();
90
91 CConcept *topConcept = tBox->getTopConcept();
92 mBottomConcept = tBox->getBottomConcept();
93 mTopConcept = tBox->getTopConcept();
94
95 mMemMan = ontology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager();
96 mOnto = ontology;
97
98
99 CConfiguration* config = context->getConfiguration();
100 mConfAbsorbDisjunctions = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.DisjunctionToImplicationAbsorption",true);
101 mConfAbsorbSimpleDisjunctions = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.DisjunctionToImplicationAbsorptionByExistingTriggers",true);
102 mConfAbsorbEqClassDefinitions = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.EquivalentDefinitionToSubclassImplicationAbsorption",true);
103 mConfPartialGCIAbsorption = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.PartialGCIImplicationAbsorption",true);
104 mConfPartialAbsorbEqClassDefinitions = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.PartialEquivalentDefinitionToCandidatesAbsorption",true);
105 mConfPartialDisjunctionsAbsorption = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.PartialDisjunctionAbsorption",true);
106
107 mConfNominalSchemaBackPropagation = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.NominalSchemaBackPropagation",true);
108 mConfNominalSchemaPathPreabsorption = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.NominalSchemaPathPreabsorption",true);
109 mConfDatatypeAbsorption = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.DatatypeAbsorption",true);
110 mConfNominalSchemaPathPreabsorption = false;
111
112 mConfCardinalityQualificationTriggerAbsorption = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.CardinalityQualificationTriggerAbsorption",true);
113 mConfPartialCardinalityQualificationTriggerAbsorption = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.CardinalityQualificationTriggerPartialAbsorption",true);
114 mConfOnlyPositiveCardinalityQualificationTriggerAbsorption = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.CardinalityQualificationTriggerOnlyPositiveAbsorption",false);
115
116
117 if (mConfAbsorbDisjunctions || mConfAbsorbSimpleDisjunctions) {
118 mImpRepVec = mBox->getImplicationReplacementVector(true);
119 }
120
121 mTriggerImplHash = tBox->getTriggerImplicationHash(true);
122 mEquivConCandidateHash = tBox->getEquivalentConceptCandidateHash(true);
123 mCandidateEquivConHash = tBox->getCandidateEquivalentConceptHash(true);
124 mEquivConNonCandidateSet = tBox->getEquivalentConceptNonCandidateSet(true);
125 mRoleDomainTriggerConceptHash = tBox->getRoleDomainTriggerConceptHash(false);
126 mIndividualTriggerConceptHash = tBox->getIndividualTriggerConceptHash(false);
127
128 mBranchTriggVec = mBox->getBranchingTriggerVector();
129 mNomSchemaTemplVec = mBox->getNominalSchemaTemplateVector(false);
130
131 mNextVariableID = 0;
132
133 mStatInvRolesGenerated = 0;
134 mStatGCIAbsorbed = 0;
135 mStatGCINormalAbsorbed = 0;
136 mStatGCINormalSchemaAbsorbed = 0;
137 mStatGCIAssertionAbsorbed = 0;
138 mStatGCITotal = 0;
139 mStatEqAbsorbed = 0;
140 mStatEqTotal = 0;
141 mStatImplConceptsGenerated = 0;
142 mStatGCIAbsorptionPartialExtended = 0;
143 mStatGCIAbsorptionAssuring = 0;
144 mStatGCIPartialAbsorbed = 0;
145 mStatReusedImplications = 0;
146 mStatOptimizedRemovedTriggers = 0;
147
148
149 if (ontology->getIncrementalRevisionData()->isIncrementalOntology()) {
150 if (ontology->getIncrementalRevisionData()->getAxiomChangeData()->hasChangedABoxAxioms()) {
151 CIndividualVector* indiVec = aBox->getIndividualVector(false);
152 if (indiVec && mIndividualTriggerConceptHash) {
153 for (CBOXHASH<cint64,CConcept*>::const_iterator it = mIndividualTriggerConceptHash->constBegin(), itEnd = mIndividualTriggerConceptHash->constEnd(); it != itEnd; ++it) {
154 cint64 indiID = it.key();
155 CConcept* triggerConcept = it.value();
156 CIndividual* locIndi = indiVec->getLocalData(indiID);
157 if (locIndi) {
158 CConceptAssertionLinker* assLinker = CObjectAllocator< CConceptAssertionLinker >::allocateAndConstruct(mMemMan);
159 assLinker->initNegLinker(triggerConcept,false);
160 locIndi->addAssertionConceptLinker(assLinker);
161 }
162 }
163 }
164 }
165 }
166
167
168 if (mConfAbsorbEqClassDefinitions) {
169
170 QList<CAbsorpEquivalentClassItem> equivConceptAbsorbItemList;
171 QList<CConcept*> equivConceptNotAbsorbList;
172 // try to absorb equivalent classes expressions
173 for (cint64 conIdx = 0; conIdx < conceptCount; conIdx++) {
174 CConcept* concept = mConceptVec->getLocalData(conIdx);
175 if (concept) {
176 cint64 opCode = concept->getOperatorCode();
177 if (opCode == CCEQ) {
178 ++mStatEqTotal;
179
180 if (isEquivalenceConceptTriggeredImplicationAbsorbable(concept,false)) {
181 // absorb to subclass and implication trigger
182 concept->setOperatorCode(CCSUB);
183 equivConceptAbsorbItemList.append(CAbsorpEquivalentClassItem(concept,concept->getOperandList()));
184 ++mStatEqAbsorbed;
185 } else {
186 equivConceptNotAbsorbList.append(concept);
187 }
188 }
189 }
190 }
191
192 //foreach (CConcept* concept, equivConceptAbsorbList) {
193 // createEquivalenceAbsorbedTriggeredImplication(concept,false);
194 //}
195 foreach (const CAbsorpEquivalentClassItem& eqConceptAbsItem, equivConceptAbsorbItemList) {
196 createEquivalenceAbsorbedTriggeredImplication(eqConceptAbsItem.mEqConcept,false,eqConceptAbsItem.mAbsorpOpLinker);
197 }
198
199 foreach (CConcept* concept, equivConceptNotAbsorbList) {
200
201 //QString iriClassNameString = CIRIName::getRecentIRIName(concept->getClassNameLinker());
202 //if (iriClassNameString == "http://rewerse.net/I5/NS/2006/r3#LanguageResource") {
203 // COntologyTextFormater::writeOntologyToFile(ontology,"xyztTBox.txt");
204 // bool bug = true;
205 //}
206
207 if (mConfPartialAbsorbEqClassDefinitions && isEquivalenceConceptCandidateExtractable(concept,false)) {
208 CConcept* candidateTriggerConcept = getEquivalenceConceptCandidateTriggeredImplication(concept,false);
209 CConcept* eqConCand = createCandidateEquivalentConcept(concept);
210 addUnfoldingConceptForConcept(candidateTriggerConcept,eqConCand,false);
211 mEquivConCandidateHash->insert(concept,eqConCand);
212 mCandidateEquivConHash->insert(eqConCand,concept);
213 } else {
214 mEquivConNonCandidateSet->insert(concept);
215 }
216 }
217
218 }
219
220 mFirstNewConceptTag = mConceptVec->getItemCount();
221 mLastNewConceptTag = mFirstNewConceptTag;
222
223
224 if (topConcept) {
225 CSortedNegLinker<CConcept*>* gciConLinker = topConcept->getOperandList();
226
227 QList< TConceptNegationPair > replaceConceptList;
228 CSortedNegLinker<CConcept*>* lastgciConLinker = nullptr;
229 CSortedNegLinker<CConcept*>* gciConLinkerIt = gciConLinker;
230 while (gciConLinkerIt) {
231 CConcept* opCon = gciConLinkerIt->getData();
232 bool opNegation = gciConLinkerIt->isNegated();
233 bool removed = false;
234 cint64 opCode = opCon->getOperatorCode();
235 if (!opNegation && opCode == CCAND || opNegation && opCode == CCOR) {
236 collectConjunctions(opCon,opNegation,replaceConceptList);
237 removed = true;
238 }
239 if (removed) {
240 if (lastgciConLinker) {
241 lastgciConLinker->setNext(gciConLinkerIt->getNext());
242 } else {
243 topConcept->setOperandList(gciConLinkerIt->getNext());
244 }
245 topConcept->incOperandCount(-1);
246 } else {
247 lastgciConLinker = gciConLinkerIt;
248 }
249
250 gciConLinkerIt = gciConLinkerIt->getNext();
251 }
252
253 for (QList< TConceptNegationPair >::const_iterator it = replaceConceptList.constBegin(), itEnd = replaceConceptList.constEnd(); it != itEnd; ++it) {
254 TConceptNegationPair conNegPair(*it);
255 addConceptToImplied(topConcept,conNegPair.first,conNegPair.second);
256 }
257
258 lastgciConLinker = nullptr;
259 gciConLinker = topConcept->getOperandList();
260 gciConLinkerIt = gciConLinker;
261 while (gciConLinkerIt) {
262 CConcept* opCon = gciConLinkerIt->getData();
263 bool opNegation = gciConLinkerIt->isNegated();
264 ++mStatGCITotal;
265 bool absorbed = false;
266
267 mFirstNewConceptTag = mLastNewConceptTag;
268
269
270 //QString iriClassNameString = CIRIName::getRecentIRIName(opCon->getOperandList()->getData()->getClassNameLinker());
271 //if (iriClassNameString == "http://purl.org/imbi/dco/dco#BacterialInfectiousPathologicalProcess") {
272 // COntologyTextFormater::writeOntologyToFile(ontology,"xyztTBox.txt");
273 // bool bug = true;
274 //}
275
276
277 KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(mDebugLastGCIString = generateDebugGCIConceptString(opCon,opNegation));
278
279
280 if (!absorbed && absorbNominalConceptsToAssertions(opCon, opNegation)) {
281 ++mStatGCIAssertionAbsorbed;
282 absorbed = true;
283 }
284
285
286 if (!absorbed && mConfGlobalNegatedSelfRestrictionsToRoleDomainAbsorption && absorbNegatedSelfToRoleDomain(opCon, opNegation)) {
287 // better for saturation
288 ++mStatGCIAssertionAbsorbed;
289 absorbed = true;
290 }
291
292
293 if (!absorbed && absorbNominalSchemaGCIConceptsToTriggeredImplications(opCon,opNegation)) {
294 ++mStatGCINormalSchemaAbsorbed;
295 absorbed = true;
296 }
297
298 if (!absorbed && absorbGCIConceptsToTriggeredImplications(opCon,opNegation)) {
299 ++mStatGCINormalAbsorbed;
300 KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(mDebugLastAbsorbedGCITechniqueString = QString("implication absorbed"));
301 absorbed = true;
302 }
303
304
305 if (!absorbed && mConfPartialGCIAbsorption) {
306 if (absorbPartialGCIConceptsToTriggeredImplications(opCon,opNegation)) {
307 ++mStatGCIPartialAbsorbed;
308 KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(mDebugLastAbsorbedGCITechniqueString = QString("partial implication absorbed"));
309 absorbed = true;
310 }
311 }
312
313
314 if (absorbed) {
315 ++mStatGCIAbsorbed;
316 mLastNewConceptTag = mConceptVec->getItemCount();
317 KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(mDebugLastAbsorbedGCIConceptString = generateDebugGeneratedAbsorbedImplicationString(mFirstNewConceptTag,mLastNewConceptTag));
318 KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(mDebugLastAbsorbedGCIString = QString("GCI:<br>\r\n<br>\r\n%1<br>\r\n%2 to<br>\r\n<br>\r\n%3<p>\r\n\r\n").arg(mDebugLastGCIString).arg(mDebugLastAbsorbedGCITechniqueString).arg(mDebugLastAbsorbedGCIConceptString));
319 KONCLUCE_PREPROCESSING_TRIGGERED_IMPLICATION_STRING_INSTRUCTION(mDebugTotalAbsorbedGCIString += mDebugLastAbsorbedGCIString);
320 if (lastgciConLinker) {
321 lastgciConLinker->setNext(gciConLinkerIt->getNext());
322 } else {
323 topConcept->setOperandList(gciConLinkerIt->getNext());
324 }
325 topConcept->incOperandCount(-1);
326 } else {
327 lastgciConLinker = gciConLinkerIt;
328 }
329
330 gciConLinkerIt = gciConLinkerIt->getNext();
331 }
332 }
333
334
335
336 if (mConfOnlyPositiveDisjunctionsAbsorption) {
337 for (cint64 conIdx = 0; conIdx < conceptCount; conIdx++) {
338 CConcept* concept = mConceptVec->getData(conIdx);
339 if (concept && concept->hasClassName()) {
340 collectPositiveConcepts(concept,false,&mPositiveConceptReferencedSet);
341 }
342 }
343 }
344
345
346 if (mConfCardinalityQualificationTriggerAbsorption) {
347 for (cint64 conIdx = 0; conIdx < conceptCount; conIdx++) {
348 CConcept* concept = mConceptVec->getLocalData(conIdx);
349 if (concept) {
350 cint64 opCode = concept->getOperatorCode();
351 bool absorbable = false;
352 bool absorbNeg = false;
353 bool absorbPos = false;
354 bool partialAbsorbable = false;
355 if (opCode == CCATMOST) {
356 absorbNeg = true;
357 absorbPos = true;
358 } else if (opCode == CCATLEAST) {
359 absorbNeg = false;
360 absorbPos = true;
361 }
362 if (absorbPos) {
363 if (!mConfOnlyPositiveCardinalityQualificationTriggerAbsorption || mPositiveConceptReferencedSet.contains(TConceptNegationPair(concept,absorbNeg))) {
364 if (isCardinalityConceptQualificationTriggerAbsorbable(concept,absorbNeg)) {
365 absorbable = true;
366 } else if (mConfPartialCardinalityQualificationTriggerAbsorption && isCardinalityConceptPartialQualificationTriggerAbsorbable(concept,absorbNeg)) {
367 absorbable = true;
368 }
369 }
370 }
371 CConcept* absorbedImpCon = nullptr;
372 if (absorbable) {
373 CConceptRoleBranchingTrigger* branchingTriggers = createCardinalityQualificationPartialAbsorbedTriggers(concept,absorbNeg);
374 mBranchTriggVec->setData(conIdx,branchingTriggers);
375 }
376 }
377 }
378 }
379
380
381 createConceptOfInterestAbsorptions(false);
382 createDisjunctionAbsorptions(false);
383
384 for (QList<CSortedNegLinker<CConcept*>*>::const_iterator it = mLaterTopConceptTriggerAddList.constBegin(), itEnd = mLaterTopConceptTriggerAddList.constEnd(); it != itEnd; ++it) {
385 CSortedNegLinker<CConcept*>* newOpLinker = *it;
386 topConcept->addOperandLinker(newOpLinker);
387 topConcept->incOperandCount();
388 }
389
390
391 asorbForallsToRanges(topConcept);
392
393
394
395
396 mStatInvRolesGenerated = mRoleInverseRoleCreateHash.count();
397 CConcreteOntologyInverseRoleBuilder::createDelayedInverseRoles(&mRoleInverseRoleCreateHash,mOnto);
398
399
400 optimizeTriggerStructure();
401
402
403 LOG(INFO,"::Konclude::Reasoner::Preprocess::TriggeredImplicationAbsorber",logTr("Absorbed %1 of %2 equivalence class definitions.").arg(mStatEqAbsorbed).arg(mStatEqTotal),this);
404 LOG(INFO,"::Konclude::Reasoner::Preprocess::TriggeredImplicationAbsorber",logTr("Absorbed %1 of %2 GCI definitions.").arg(mStatGCIAbsorbed).arg(mStatGCITotal),this);
405 if (mStatGCITotal > 0) {
406 LOG(INFO,"::Konclude::Reasoner::Preprocess::TriggeredImplicationAbsorber",logTr("Absorbed %1 GCI definitions only partially and extended %2 absorptions partially.").arg(mStatGCIPartialAbsorbed).arg(mStatGCIAbsorptionPartialExtended),this);
407 }
408 if (mStatGCINormalSchemaAbsorbed > 0) {
409 LOG(INFO,"::Konclude::Reasoner::Preprocess::TriggeredImplicationAbsorber",logTr("Absorbed %1 GCI with nominal schemas.").arg(mStatGCINormalSchemaAbsorbed),this);
410 }
411 if (mStatGCIAssertionAbsorbed > 0) {
412 LOG(INFO, "::Konclude::Reasoner::Preprocess::TriggeredImplicationAbsorber", logTr("Absorbed %1 GCI to assertions.").arg(mStatGCIAssertionAbsorbed), this);
413 }
414 LOG(INFO,"::Konclude::Reasoner::Preprocess::TriggeredImplicationAbsorber",logTr("Generated %1 triggered implication concepts and %2 additional inverse roles.").arg(mStatImplConceptsGenerated).arg(mStatInvRolesGenerated),this);
415
416 return ontology;
417 }
418
419
420
421
422 CConcreteOntology* CTriggeredImplicationBinaryAbsorberPreProcess::continuePreprocessing() {
423 if (mOnto) {
424 createConceptOfInterestAbsorptions(true);
425 createDisjunctionAbsorptions(true);
426 }
427 return mOnto;
428 }
429
430
431 void CTriggeredImplicationBinaryAbsorberPreProcess::createConceptOfInterestAbsorptions(bool continuationExtension) {
432 CBOXLIST<TConceptNegPair>* conIntList = mTBox->getConceptOfInterestList(false);
433 if (conIntList && !conIntList->isEmpty()) {
434 CBOXSET<TConceptNegPair>* triggeredConIntSet = mTBox->getTriggeredConceptOfInterestSet(true);
435 cint64 conIntCount = conIntList->count();
436 for (cint64 triggeredCount = triggeredConIntSet->count(); triggeredCount < conIntCount; ++triggeredCount) {
437 TConceptNegPair conNegPair(conIntList->at(triggeredCount));
438 CConcept* concept = conNegPair.first;
439 bool negation = conNegPair.second;
440 if (!triggeredConIntSet->contains(conNegPair)) {
441 createConceptOfInterestAbsorption(concept, negation, continuationExtension);
442 triggeredConIntSet->insert(conNegPair);
443 collectPositiveConcepts(concept, negation, &mPositiveConceptReferencedSet);
444 }
445 }
446 }
447 }
448
449
450
451 void CTriggeredImplicationBinaryAbsorberPreProcess::createDisjunctionAbsorptions(bool continuationExtension) {
452 cint64 conceptCount = mConceptVec->getItemCount();
453 if (mConfAbsorbDisjunctions || mConfPartialDisjunctionsAbsorption || mConfAbsorbSimpleDisjunctions) {
454 for (cint64 conIdx = mLastDisjunctId; conIdx < conceptCount; conIdx++) {
455 CConcept* concept = mConceptVec->getLocalData(conIdx);
456 if (concept) {
457
458 bool requiresBackpropagation = false;
459 if (continuationExtension && mLastDisjunctId > 0) {
460 requiresBackpropagation = true;
461 }
462
463 cint64 opCode = concept->getOperatorCode();
464 bool absorb = false;
465 bool absorbable = false;
466 bool absorbNeg = false;
467 bool absorbPos = false;
468 bool partialAbsorbable = false;
469 cint64 opCount = concept->getOperandCount();
470 if (opCount > 1) {
471 if (opCode == CCAND) {
472 absorbNeg = true;
473 absorbPos = true;
474 absorb = true;
475 } else if (opCode == CCOR) {
476 absorbNeg = false;
477 absorbPos = true;
478 absorb = true;
479 }
480 if (absorb) {
481 bool localRepData = false;
482 CReplacementData* prevReplData = mImpRepVec->getData(conIdx, &localRepData);
483 if ((!prevReplData || !localRepData)) {
484 if (absorbPos) {
485 if (!mConfOnlyPositiveDisjunctionsAbsorption || mPositiveConceptReferencedSet.contains(TConceptNegationPair(concept, absorbNeg))) {
486 if (mConfAbsorbSimpleDisjunctions && isDisjunctionConceptSimpleTriggeredImplicationAbsorbable(concept, absorbNeg)) {
487 absorbable = true;
488 } else if (mConfAbsorbDisjunctions && isDisjunctionConceptTriggeredImplicationAbsorbable(concept, absorbNeg)) {
489 // add implication trigger absorption
490 absorbable = true;
491 } else if (mConfPartialDisjunctionsAbsorption && isDisjunctionConceptPartialTriggeredImplicationAbsorbable(concept, absorbNeg)) {
492 partialAbsorbable = true;
493 }
494 }
495 }
496
497
498 CConcept* absorbedImpCon = nullptr;
499 if (!requiresBackpropagation) {
500 if (absorbable) {
501 absorbedImpCon = createDisjunctionAbsorbedTriggeredImplication(concept, absorbNeg);
502 } else if (partialAbsorbable) {
503 CConceptRoleBranchingTrigger* branchingTriggers = createDisjunctionPartialAbsorbedBranchTriggers(concept, absorbNeg);
504 mBranchTriggVec->setData(concept->getConceptTag(), branchingTriggers);
505 }
506 } else {
507 if (absorbable || partialAbsorbable) {
508 if (!mCreatedImpliedDisjunctions.contains(concept)) {
509 CConcept* disjBackPropTrigger = createTriggerConcept(true);
510 absorbedImpCon = createDisjunctionAbsorbedBackpropagationTriggeredImplication(concept, absorbNeg, disjBackPropTrigger);
511 addUnfoldingConceptForConcept(disjBackPropTrigger, absorbedImpCon, false);
512 absorbedImpCon = disjBackPropTrigger;
513 }
514 }
515 }
516
517 if (absorbedImpCon) {
518
519 CReplacementData* replData = prevReplData;
520 if (!localRepData) {
521 replData = CObjectAllocator<CReplacementData>::allocateAndConstruct(mMemMan);
522 replData->initReplacementData(prevReplData);
523 mImpRepVec->setData(concept->getConceptTag(), replData);
524 }
525 replData->setImplicationReplacementConcept(absorbedImpCon);
526 }
527
528 }
529 }
530 }
531 }
532 }
533 mLastDisjunctId = conceptCount;
534 }
535 }
536
537
538 void CTriggeredImplicationBinaryAbsorberPreProcess::asorbForallsToRanges(CConcept* topConcept) {
539 CSortedNegLinker<CConcept*>* gciConLinker = topConcept->getOperandList();
540 CSortedNegLinker<CConcept*>* lastgciConLinker = nullptr;
541 CSortedNegLinker<CConcept*>* gciConLinkerIt = gciConLinker;
542 while (gciConLinkerIt) {
543 CConcept* opCon = gciConLinkerIt->getData();
544 bool opNegation = gciConLinkerIt->isNegated();
545 bool removed = false;
546 cint64 opCode = opCon->getOperatorCode();
547 if (!opNegation && (opCode == CCALL || opCode == CCIMPLALL) || opNegation && (opCode == CCSOME)) {
548 CRole* role = opCon->getRole();
549 CRole* locatedRole = CConceptRoleIndividualLocator::getLocatedRole(role,mOnto);
550 for (CSortedNegLinker<CConcept*>* opLinkerIt = opCon->getOperandList(); opLinkerIt; opLinkerIt = opLinkerIt->getNext()) {
551 addRoleRangeConcept(locatedRole,opLinkerIt->getData(),opLinkerIt->isNegated()^opNegation);
552 }
553 removed = true;
554 }
555 if (removed) {
556 if (lastgciConLinker) {
557 lastgciConLinker->setNext(gciConLinkerIt->getNext());
558 } else {
559 topConcept->setOperandList(gciConLinkerIt->getNext());
560 }
561 topConcept->incOperandCount(-1);
562 } else {
563 lastgciConLinker = gciConLinkerIt;
564 }
565
566 gciConLinkerIt = gciConLinkerIt->getNext();
567 }
568 }
569
570
571 bool CTriggeredImplicationBinaryAbsorberPreProcess::collectConjunctions(CConcept* concept, bool negated, QList< TConceptNegationPair >& conjList) {
572 cint64 opCode = concept->getOperatorCode();
573 if (!negated && opCode == CCAND || negated && opCode == CCOR) {
574 for (CSortedNegLinker<CConcept*>* opLinkIt = concept->getOperandList(); opLinkIt; opLinkIt = opLinkIt->getNext()) {
575 CConcept* opConcept = opLinkIt->getData();
576 bool opNegation = opLinkIt->isNegated()^negated;
577 collectConjunctions(opConcept,opNegation,conjList);
578 }
579 } else {
580 conjList.append(TConceptNegationPair(concept,negated));
581 }
582 return true;
583 }
584
585
586 void CTriggeredImplicationBinaryAbsorberPreProcess::replaceTrigger(CConcept* baseConcept, CConcept* replaceConcept, bool negated) {
587 for (CSortedNegLinker<CConcept*>* opLinker = replaceConcept->getOperandList(); opLinker; opLinker = opLinker->getNext()) {
588 CConcept* opConcept = opLinker->getData();
589 bool replaceOperand = true;
590 bool negatedReplacement = opLinker->isNegated() ^ negated;
591 if (opConcept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/* == CCIMPLTRIG*/) {
592 if (mTriggCountHash[opConcept].mCount <= 1) {
593 replaceOperand = false;
594 replaceTrigger(baseConcept,opConcept,negatedReplacement);
595 }
596 }
597 if (replaceOperand) {
598 ++mStatOptimizedRemovedTriggers;
599 addUnfoldingConceptForConcept(baseConcept,opConcept,negatedReplacement);
600 }
601 }
602 }
603
604
605 void CTriggeredImplicationBinaryAbsorberPreProcess::replaceOneTrigger(CConcept* baseConcept, CConcept* replaceConcept, bool negated) {
606 for (CSortedNegLinker<CConcept*>* opLinker = replaceConcept->getOperandList(); opLinker; opLinker = opLinker->getNext()) {
607 CConcept* opConcept = opLinker->getData();
608 bool replaceOperand = true;
609 bool negatedReplacement = opLinker->isNegated() ^ negated;
610 if (opConcept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/* == CCIMPLTRIG*/) {
611 if (mTriggCountHash[opConcept].mCount <= 1) {
612 CSortedNegLinker<CConcept*>* opOpLinker = opConcept->getOperandList();
613 if (opOpLinker && !opOpLinker->getNext() && !opOpLinker->getData()->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_IMPL_TYPE | CConceptOperator::CCF_VARBINDJOIN)/* != CCIMPL*/) {
614 replaceOperand = false;
615 replaceTrigger(baseConcept,opConcept,negatedReplacement);
616 }
617 }
618 }
619 if (replaceOperand) {
620 ++mStatOptimizedRemovedTriggers;
621 addUnfoldingConceptForConcept(baseConcept,opConcept,negatedReplacement);
622 }
623 }
624 }
625
626
627 void CTriggeredImplicationBinaryAbsorberPreProcess::optimizeTriggerStructure() {
628
629 cint64 optimisingRemovedTrigger = 0;
630
631 cint64 conceptCount = mConceptVec->getItemCount();
632 for (cint64 conIdx = 0; conIdx < conceptCount; conIdx++) {
633 CConcept* concept = mConceptVec->getData(conIdx);
634 if (concept) {
635 for (CSortedNegLinker<CConcept*>* opLinker = concept->getOperandList(); opLinker; opLinker = opLinker->getNext()) {
636 CConcept* opConcept = opLinker->getData();
637 if (opConcept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/* == CCIMPLTRIG*/) {
638 mTriggCountHash[opConcept].incCount(1);
639 }
640 }
641 }
642 }
643 cint64 brCount = mBranchTriggVec->getItemCount();
644 for (cint64 brIdx = 0; brIdx < brCount; ++brIdx) {
645 CConceptRoleBranchingTrigger* brTrigger = mBranchTriggVec->getData(brIdx);
646 if (brTrigger) {
647 if (brTrigger->isConceptTrigger()) {
648 CConcept* concept = brTrigger->getTriggerConcept();
649 if (concept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/* == CCIMPLTRIG*/) {
650 mTriggCountHash[concept].incCount(2);
651 }
652 }
653 }
654 }
655
656 for (cint64 conIdx = 0; conIdx < conceptCount; conIdx++) {
657 CConcept* concept = mConceptVec->getLocalData(conIdx);
658 if (concept) {
659 cint64 opCode = concept->getOperatorCode();
660 if (opCode == CCSUB || opCode == CCAND || concept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/*opCode == CCIMPLTRIG*/) {
661 CSortedNegLinker<CConcept*>* lastLinker = nullptr;
662 for (CSortedNegLinker<CConcept*>* opLinker = concept->getOperandList(); opLinker; opLinker = opLinker->getNext()) {
663 CConcept* opConcept = opLinker->getData();
664 bool opNegated = opLinker->isNegated();
665 if (opConcept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/* == CCIMPLTRIG*/) {
666 if (mTriggCountHash[opConcept].mCount <= 1) {
667 ++optimisingRemovedTrigger;
668 concept->incOperandCount(-1);
669 if (lastLinker) {
670 lastLinker->setNext(opLinker->getNext());
671 replaceTrigger(concept,opConcept,opNegated);
672 } else {
673 replaceTrigger(concept,opConcept,opNegated);
674 CSortedNegLinker<CConcept*>* opLinkerIt = concept->getOperandList();
675 while (opLinkerIt && opLinkerIt->getNext() != opLinker) {
676 opLinkerIt = opLinkerIt->getNext();
677 }
678 opLinkerIt->setNext(opLinker->getNext());
679 lastLinker = opLinkerIt;
680 }
681 } else {
682 lastLinker = opLinker;
683 }
684 }
685 }
686 } else if (concept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_IMPL_TYPE | CConceptOperator::CCF_VARBINDJOIN | CConceptOperator::CCF_VARBINDGROUND)/*opCode == CCIMPL*/) {
687 CSortedNegLinker<CConcept*>* opLinker = concept->getOperandList();
688 if (opLinker) {
689 CConcept* opConcept = opLinker->getData();
690 bool opNegated = opLinker->isNegated();
691 if (opConcept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/* == CCIMPLTRIG*/) {
692 if (mTriggCountHash[opConcept].mCount <= 1) {
693 CSortedNegLinker<CConcept*>* opOpLinker = opConcept->getOperandList();
694 if (opOpLinker && !opOpLinker->getNext() && !opOpLinker->getData()->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_IMPL_TYPE | CConceptOperator::CCF_VARBINDJOIN)/* != CCIMPL*/) {
695 ++optimisingRemovedTrigger;
696 concept->setOperandList(opLinker->getNext());
697 concept->incOperandCount(-1);
698 replaceOneTrigger(concept,opConcept,opNegated);
699 }
700 }
701 }
702 }
703 } else {
704 if (concept->getOperandCount() == 1) {
705 CSortedNegLinker<CConcept*>* opLinker = concept->getOperandList();
706 CConcept* opConcept = opLinker->getData();
707 bool opNegated = opLinker->isNegated();
708 if (opConcept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)/* == CCIMPLTRIG*/) {
709 if (mTriggCountHash[opConcept].mCount <= 1) {
710 CSortedNegLinker<CConcept*>* opOpLinker = opConcept->getOperandList();
711 if (opOpLinker && !opOpLinker->getNext() && !opOpLinker->getData()->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_IMPL_TYPE | CConceptOperator::CCF_VARBINDJOIN)/* != CCIMPL*/) {
712 ++optimisingRemovedTrigger;
713 concept->setOperandList(nullptr);
714 concept->incOperandCount(-1);
715 replaceOneTrigger(concept,opConcept,opNegated);
716 }
717 }
718 }
719 }
720 }
721 }
722 }
723
724
725 }
726
727
728
729 void CTriggeredImplicationBinaryAbsorberPreProcess::collectPositiveConcepts(CConcept* initalConcept, bool initalNegated, QSet<TConceptNegationPair>* positiveConceptSet, bool recursiveDefinition) {
730 TConceptNegationPair processConNegPair(initalConcept,initalNegated);
731 if (!positiveConceptSet->contains(processConNegPair)) {
732 positiveConceptSet->insert(processConNegPair);
733 QList<TConceptNegationPair> processConceptList;
734 processConceptList.append(processConNegPair);
735 while (!processConceptList.isEmpty()) {
736 TConceptNegationPair conNegPair(processConceptList.takeFirst());
737
738 CConcept* concept = conNegPair.first;
739 bool negated = conNegPair.second;
740
741 cint64 opCode = concept->getOperatorCode();
742 CConceptOperator* conOperator = concept->getConceptOperator();
743 CSortedNegLinker<CConcept*>* opConLinker = concept->getOperandList();
744 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) {
745 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
746 while (opConLinkerIt) {
747 CConcept* opConcept = opConLinkerIt->getData();
748 bool opNegation = opConLinkerIt->isNegated()^negated;
749 TConceptNegationPair opConNegPair(opConcept,opNegation);
750 if (!positiveConceptSet->contains(opConNegPair)) {
751 positiveConceptSet->insert(opConNegPair);
752 processConceptList.append(opConNegPair);
753 }
754 opConLinkerIt = opConLinkerIt->getNext();
755 }
756 } else if (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_IMPL_TYPE)) {
757 CSortedNegLinker<CConcept*>* firstOpConLinker = opConLinker;
758 if (firstOpConLinker) {
759 CConcept* opConcept = firstOpConLinker->getData();
760 TConceptNegationPair opConNegPair(opConcept,false);
761 if (!positiveConceptSet->contains(opConNegPair)) {
762 positiveConceptSet->insert(opConNegPair);
763 processConceptList.append(opConNegPair);
764 }
765 }
766 } else if (opCode == CCAQCHOOCE) {
767 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
768 while (opConLinkerIt) {
769 CConcept* opConcept = opConLinkerIt->getData();
770 if (opConLinkerIt->isNegated() == negated) {
771 TConceptNegationPair opConNegPair(opConcept,false);
772 if (!positiveConceptSet->contains(opConNegPair)) {
773 positiveConceptSet->insert(opConNegPair);
774 processConceptList.append(opConNegPair);
775 }
776 }
777 opConLinkerIt = opConLinkerIt->getNext();
778 }
779 } else if (opCode == CCATMOST || opCode == CCATLEAST) {
780 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
781 while (opConLinkerIt) {
782 CConcept* opConcept = opConLinkerIt->getData();
783 TConceptNegationPair opConNegPair(opConcept,opConLinkerIt->isNegated());
784 if (!positiveConceptSet->contains(opConNegPair)) {
785 positiveConceptSet->insert(opConNegPair);
786 processConceptList.append(opConNegPair);
787 }
788 opConLinkerIt = opConLinkerIt->getNext();
789 }
790 } else if (!negated && (conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE))) {
791 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
792 while (opConLinkerIt) {
793 CConcept* opConcept = opConLinkerIt->getData();
794 TConceptNegationPair opConNegPair(opConcept,opConLinkerIt->isNegated());
795 if (!positiveConceptSet->contains(opConNegPair)) {
796 positiveConceptSet->insert(opConNegPair);
797 processConceptList.append(opConNegPair);
798 }
799 opConLinkerIt = opConLinkerIt->getNext();
800 }
801 }
802 }
803 }
804 }
805
806
807 QString CTriggeredImplicationBinaryAbsorberPreProcess::generateDebugGCIConceptString(CConcept* concept, bool conceptNegation) {
808 mDebugGCIString = CConceptTextFormater::getConceptString(concept,conceptNegation);
809 return mDebugGCIString;
810 }
811
812
813 QString CTriggeredImplicationBinaryAbsorberPreProcess::generateDebugGeneratedAbsorbedImplicationString(cint64 minNewConceptTag, cint64 lastNewConceptTag) {
814 QString absorbedString;
815 for (cint64 tag = minNewConceptTag; tag <= lastNewConceptTag; ++tag) {
816 CConcept* concept = mConceptVec->getData(tag);
817 if (concept) {
818 QString tmpString = CConceptTextFormater::getConceptString(concept,false);
819 absorbedString += QString("%1<br>\r\n").arg(tmpString);
820 }
821 }
822 mDebugAbsorbedString = absorbedString;
823 return absorbedString;
824 }
825
826
827 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createImpliedConcept() {
828 CConcept* concept = createNewConcept();
829 concept->setOperatorCode(CCAND);
830 return concept;
831 }
832
833
834 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createCandidateEquivalentConcept(CConcept* eqConcept) {
835 CConcept* concept = createNewConcept();
836 addUnfoldingConceptForConcept(concept,eqConcept,false);
837 concept->setOperatorCode(CCEQCAND);
838 return concept;
839 }
840
841
842 bool CTriggeredImplicationBinaryAbsorberPreProcess::addConceptToImplied(CConcept* impliedConcept, CConcept* concept, bool negated) {
843 CSortedNegLinker<CConcept*>* newBaseOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
844 newBaseOpCon->init(concept,negated,impliedConcept->getOperandList());
845 impliedConcept->setOperandList(newBaseOpCon);
846 impliedConcept->incOperandCount();
847 return true;
848 }
849
850 bool CTriggeredImplicationBinaryAbsorberPreProcess::addSubClassConcept(CConcept* subclassConcept, CConcept* addedConcept, bool negated) {
851 CSortedNegLinker<CConcept*>* newBaseOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
852 newBaseOpCon->init(addedConcept,negated,subclassConcept->getOperandList());
853 subclassConcept->setOperandList(newBaseOpCon);
854 subclassConcept->incOperandCount();
855 subclassConcept->setOperatorCode(CCSUB);
856 return true;
857 }
858
859
860 bool CTriggeredImplicationBinaryAbsorberPreProcess::addRoleDomainConcept(CRole* role, CConcept* addedConcept, bool negated) {
861 CSortedNegLinker<CConcept*>* newBaseOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
862 newBaseOpCon->init(addedConcept,negated,role->getDomainConceptList());
863 role->setDomainConceptList(newBaseOpCon);
864 return true;
865 }
866
867
868
869 bool CTriggeredImplicationBinaryAbsorberPreProcess::addRoleRangeConcept(CRole* role, CConcept* addedConcept, bool negated) {
870 CSortedNegLinker<CConcept*>* newBaseOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
871 newBaseOpCon->init(addedConcept,negated,role->getRangeConceptList());
872 role->setRangeConceptList(newBaseOpCon);
873 return true;
874 }
875
876 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createNewConcept() {
877 CConcept* concept = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan);
878 concept->initConcept();
879 cint64 nextConTag = mTBox->getNextConceptID();
880 concept->initTag(nextConTag);
881 mConceptVec->setLocalData(nextConTag, concept);
882 return concept;
883 }
884
885
886 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createImplicationConcept(CConcept* impliedConcept, bool negated) {
887 CConcept* concept = createNewConcept();
888 concept->setOperatorCode(CCIMPL);
889
890 CSortedNegLinker<CConcept*>* newBaseOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
891 newBaseOpCon->init(impliedConcept,negated);
892 concept->setOperandList(newBaseOpCon);
893 concept->incOperandCount();
894
895 ++mStatImplConceptsGenerated;
896 return concept;
897 }
898
899
900
901 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createImplicationTriggerConcept(CConcept* impConcept, bool negated) {
902 CConcept* concept = createNewConcept();
903 concept->setOperatorCode(CCIMPLTRIG);
904 if (impConcept) {
905 addConceptToImplied(concept,impConcept,negated);
906 }
907 return concept;
908 }
909
910 bool CTriggeredImplicationBinaryAbsorberPreProcess::addImplicationTrigger(CConcept* implConcept, CConcept* triggerConcept, bool negated) {
911 CSortedNegLinker<CConcept*>* newTriggerOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
912 newTriggerOpCon->init(triggerConcept,negated,implConcept->getOperandList()->getNext());
913 implConcept->getOperandList()->setNext(newTriggerOpCon);
914 implConcept->incOperandCount();
915 mTriggerImplHash->insertMulti(triggerConcept,implConcept);
916 return true;
917 }
918
919
920 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createTriggerPropagationConcept(CConcept* destConcept, CRole* backwardPropRole, bool branchTiggerCreation, bool invsereRolePropagation) {
921 CConcept* concept = createNewConcept();
922 CRole* propRole = backwardPropRole;
923 if (invsereRolePropagation) {
924 propRole = getInverseRole(backwardPropRole);
925 }
926 if (branchTiggerCreation) {
927 concept->setOperatorCode(CCBRANCHALL);
928 } else {
929 concept->setOperatorCode(CCIMPLALL);
930 }
931 concept->setRole(propRole);
932 CSortedNegLinker<CConcept*>* newTriggerOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
933 newTriggerOpCon->init(destConcept,false);
934 concept->setOperandList(newTriggerOpCon);
935 concept->incOperandCount();
936 return concept;
937 }
938
939
940
941 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createNominalImplication(CConcept* destConcept, CIndividual* nominalIndi) {
942 CConcept* concept = createNewConcept();
943 concept->setOperatorCode(CCNOMINALIMPLI);
944 concept->setNominalIndividual(nominalIndi);
945 CSortedNegLinker<CConcept*>* newTriggerOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
946 newTriggerOpCon->init(destConcept, false);
947 concept->setOperandList(newTriggerOpCon);
948 concept->incOperandCount();
949 return concept;
950 }
951
952
953
954
955
956 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createDatatypeImplication(CConcept* destConcept, CDatatype* datatype) {
957 CConcept* concept = createNewConcept();
958 concept->setOperatorCode(CCDATATYPEIMPLI);
959 concept->setDatatype(datatype);
960 CSortedNegLinker<CConcept*>* newTriggerOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
961 newTriggerOpCon->init(destConcept, false);
962 concept->setOperandList(newTriggerOpCon);
963 concept->incOperandCount();
964 return concept;
965 }
966
967
968 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createDataLiteralImplication(CConcept* destConcept, CDataLiteral* dataLiteral) {
969 CConcept* concept = createNewConcept();
970 concept->setOperatorCode(CCDATALITERALIMPLI);
971 concept->setDataLiteral(dataLiteral);
972 CSortedNegLinker<CConcept*>* newTriggerOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
973 newTriggerOpCon->init(destConcept, false);
974 concept->setOperandList(newTriggerOpCon);
975 concept->incOperandCount();
976 return concept;
977 }
978
979
980
981 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createDataRestrictionImplication(CConcept* destConcept, CDatatype* datatype, CDataLiteral* dataliteral, cint64 restrictionCode) {
982 CConcept* concept = createNewConcept();
983 concept->setOperatorCode(CCDATARESTRICTIONIMPLI);
984 concept->setDatatype(datatype);
985 concept->setDataLiteral(dataliteral);
986 concept->setParameter(restrictionCode);
987 CSortedNegLinker<CConcept*>* newTriggerOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
988 newTriggerOpCon->init(destConcept, false);
989 concept->setOperandList(newTriggerOpCon);
990 concept->incOperandCount();
991 return concept;
992 }
993
994
995 CRole* CTriggeredImplicationBinaryAbsorberPreProcess::getInverseRole(CRole* role) {
996 CSortedNegLinker<CRole*>* eqInvRoleIt = role->getInverseEquivalentRoleList();
997 while (eqInvRoleIt) {
998 if (eqInvRoleIt->isNegated()) {
999 return eqInvRoleIt->getData();
1000 }
1001 eqInvRoleIt = eqInvRoleIt->getNext();
1002 }
1003 CSortedNegLinker<CRole*>* superRoleIt = role->getIndirectSuperRoleList();
1004 while (superRoleIt) {
1005 if (superRoleIt->isNegated()) {
1006 CRole* superRole = superRoleIt->getData();
1007 CSortedNegLinker<CRole*>* superRoleSuperRoleIt = superRole->getIndirectSuperRoleList();
1008 while (superRoleSuperRoleIt) {
1009 if (superRoleSuperRoleIt->isNegated() && superRoleSuperRoleIt->getData() == role) {
1010 return superRole;
1011 }
1012 superRoleSuperRoleIt = superRoleSuperRoleIt->getNext();
1013 }
1014 }
1015 superRoleIt = superRoleIt->getNext();
1016 }
1017
1018 // create inverse role
1019 CRole* invRole = CConcreteOntologyInverseRoleBuilder::createInverseRoleDelayed(role,&mRoleInverseRoleCreateHash,mOnto);
1020 ++mStatInvRolesGenerated;
1021 return invRole;
1022 }
1023
1024
1025
1026 void CTriggeredImplicationBinaryAbsorberPreProcess::createEquivalenceAbsorbedTriggeredImplication(CConcept* eqConcept, bool negated, CSortedNegLinker<CConcept*>* absorpOpLinker) {
1027 CConceptTriggerLinker* triggers = nullptr;
1028 for (CSortedNegLinker<CConcept*>* opConLinkerIt = absorpOpLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
1029 CConcept* concept = opConLinkerIt->getData();
1030 bool negated = opConLinkerIt->isNegated();
1031 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getTriggersForConcept(concept,negated));
1032 if (tmpTriggers) {
1033 triggers = tmpTriggers->append(triggers);
1034 }
1035 }
1036 CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers,nullptr);
1037 addUnfoldingConceptForConcept(impliedConceptTrigger->getTriggerConcept(),eqConcept,false);
1038
1039 }
1040
1041
1042 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::getEquivalenceConceptCandidateTriggeredImplication(CConcept* eqConcept, bool negated) {
1043 CConcept* triggeredConcept = nullptr;
1044
1045 cint64 opCode = eqConcept->getOperatorCode();
1046 if (!negated && opCode == CCEQ) {
1047 QList<TConceptNegationPair> candList;
1048 if (addAbsorbableDisjunctCandidates(eqConcept,!negated,candList)) {
1049 if (candList.count() >= 1) {
1050 QList<TConceptNegationPair> absorbList(getPartialAbsorbableDisjuncts(candList));
1051 if (!absorbList.isEmpty()) {
1052 triggeredConcept = createPartialExtendedAbsorbedImpliedTriggerCocnept(absorbList);
1053 }
1054 }
1055 }
1056 }
1057 return triggeredConcept;
1058 }
1059
1060
1061
1062 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createDisjunctionAbsorbedTriggeredImplication(CConcept* orConcept, bool negated) {
1063 CConcept* implicationConcept = nullptr;
1064
1065 cint64 opCode = orConcept->getOperatorCode();
1066 if (!negated && opCode == CCOR || negated && opCode == CCAND) {
1067 QList<TConceptNegationPair> candList;
1068 if (addAbsorbableDisjunctCandidates(orConcept,negated,candList)) {
1069 if (candList.count() >= 1) {
1070 QList<TConceptNegationPair> absorbList(splitAbsorbableDisjuncts(candList));
1071 if (!absorbList.isEmpty()) {
1072 implicationConcept = createDisjunctionAbsorbedTriggeredImplication(orConcept,negated,absorbList,candList);
1073 }
1074 }
1075 }
1076 }
1077 return implicationConcept;
1078 }
1079
1080
1081
1082
1083 CConceptRoleBranchingTrigger* CTriggeredImplicationBinaryAbsorberPreProcess::createCardinalityQualificationPartialAbsorbedTriggers(CConcept* cardConcept, bool negated) {
1084 CConceptRoleBranchingTrigger* branchTriggers = nullptr;
1085 QSet<CConcept*> conceptEqConAbsorbed;
1086 for (CSortedNegLinker<CConcept*>* opConLinker = cardConcept->getOperandList(); opConLinker; opConLinker = opConLinker->getNext()) {
1087 CConcept* concept = opConLinker->getData();
1088 bool negated = opConLinker->isNegated();
1089 if (isConceptPartialImplicationTriggerable(concept,!negated,&conceptEqConAbsorbed)) {
1090 CConceptRoleBranchingTrigger* tmpBranchTrigger = getSimpleBranchTriggersForConcept(concept,negated);
1091 if (tmpBranchTrigger) {
1092 branchTriggers = tmpBranchTrigger->append(branchTriggers);
1093 } else {
1094 CConceptRoleBranchingTrigger* tmpBranchTrigger = getBranchTiggers(getPartialTriggersForConcept(concept,negated));
1095 branchTriggers = tmpBranchTrigger->append(branchTriggers);
1096 }
1097 }
1098 }
1099 return branchTriggers;
1100 }
1101
1102
1103
1104 CConceptRoleBranchingTrigger* CTriggeredImplicationBinaryAbsorberPreProcess::createDisjunctionPartialAbsorbedBranchTriggers(CConcept* orConcept, bool negated) {
1105 CConceptRoleBranchingTrigger* branchTriggers = nullptr;
1106 cint64 opCode = orConcept->getOperatorCode();
1107 if (!negated && opCode == CCOR || negated && (opCode == CCAND)) {
1108 QList<TConceptNegationPair> candList;
1109 if (addAbsorbableDisjunctCandidates(orConcept,negated,candList)) {
1110 if (candList.count() >= 1) {
1111 QList<TConceptNegationPair> absorbList(getPartialAbsorbableDisjuncts(candList));
1112 if (!absorbList.isEmpty()) {
1113 branchTriggers = createDisjunctionPartialAbsorbedBranchTriggers(orConcept,negated,absorbList);
1114 }
1115 }
1116 }
1117 }
1118 return branchTriggers;
1119 }
1120
1121
1122
1123 CConceptRoleBranchingTrigger* CTriggeredImplicationBinaryAbsorberPreProcess::createDisjunctionPartialAbsorbedBranchTriggers(CConcept* orConcept, bool negated, const QList<TConceptNegationPair>& absorbList) {
1124 CConceptRoleBranchingTrigger* branchTriggers = nullptr;
1125 for (QList<TConceptNegationPair>::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
1126 TConceptNegationPair conNegPair(*it);
1127 CConcept* concept = conNegPair.first;
1128 bool negated = conNegPair.second;
1129 CConceptRoleBranchingTrigger* tmpBranchTrigger = getSimpleBranchTriggersForConcept(concept,!negated);
1130 if (tmpBranchTrigger) {
1131 branchTriggers = tmpBranchTrigger->append(branchTriggers);
1132 } else {
1133 CConceptRoleBranchingTrigger* tmpBranchTrigger = getBranchTiggers(getPartialTriggersForConcept(concept,!negated));
1134 branchTriggers = tmpBranchTrigger->append(branchTriggers);
1135 }
1136 }
1137 return branchTriggers;
1138 }
1139
1140
1141
1142 bool CTriggeredImplicationBinaryAbsorberPreProcess::createConceptOfInterestAbsorption(CConcept* intConcept, bool negated, bool continuationExtension) {
1143 bool absorbed = false;
1144 bool propagationActivationAbsorbable = isConceptPropagationTriggerable(intConcept, negated);
1145
1146 if (propagationActivationAbsorbable) {
1147 return createPropagationConceptOfInterestAbsorption(intConcept, negated, continuationExtension);
1148 } else {
1149 return createDirectConceptOfInterestAbsorption(intConcept, negated, continuationExtension);
1150 }
1151
1152 }
1153
1154
1155 bool CTriggeredImplicationBinaryAbsorberPreProcess::createPropagationConceptOfInterestAbsorption(CConcept* intConcept, bool negated, bool continuationExtension) {
1156
1157 TConceptNegPair intConceptNegationPair = TConceptNegPair(intConcept, negated);
1158 CConcept* candidateBackPropTriggerCon = nullptr;
1159 QHash<CConcept*, TOccuredAbsorbablePair> conceptEqConAbsorbed;
1160 bool completlyAbsorbable = isConceptImplicationTriggerable(intConcept, negated, &conceptEqConAbsorbed);
1161 bool partiallyAbsorbable = completlyAbsorbable;
1162 if (!partiallyAbsorbable) {
1163 QSet<CConcept*> conceptEqConPartialAbsorbed;
1164 partiallyAbsorbable = isConceptPartialImplicationTriggerable(intConcept, negated, &conceptEqConPartialAbsorbed);
1165 }
1166
1167 CConceptOfInterestActivationTriggeringData& activationTriggeringData = mTBox->getConceptOfInterestActivationTriggerDataHash()->operator[](TConceptNegPair(intConcept, negated));
1168
1169 CConcept* markerConcept = createMarkerConcept();
1170
1171 CConceptTriggerLinker* triggers = getPropagationTriggersForConcept(intConcept, negated, intConceptNegationPair, completlyAbsorbable);
1172 if (triggers->hasNext()) {
1173 triggers = getImplicationTriggeredConceptForTriggers(triggers, nullptr);
1174 }
1175 CConcept* triggerConcept = triggers->getTriggerConcept();
1176 addUnfoldingConceptForConcept(triggerConcept, markerConcept, false);
1177
1178 if (completlyAbsorbable) {
1179 mTBox->getTriggerConceptOfInterestHash()->insert(markerConcept, intConceptNegationPair);
1180 activationTriggeringData.setTriggeringConcept(markerConcept);
1181 } else {
1182 mTBox->getCandidateConceptOfInterestHash()->insert(markerConcept, intConceptNegationPair);
1183 activationTriggeringData.setCandidateConcept(markerConcept);
1184 }
1185
1186 return true;
1187
1188 }
1189
1190
1191
1192 CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getPropagationTriggersForConceptOperandList(CSortedNegLinker<CConcept*>* opConLinker, bool operandsNegation, bool chooseInsteadOfNegation, CConcept* concept, bool negated, TConceptNegPair& intConceptNegationPair, bool completelyAbsorbable) {
1193
1194 CConceptTriggerLinker* triggers = nullptr;
1195
1196 QList<TConceptNegPair> propagationAbsorptionList;
1197 QList<TConceptNegPair> backpropagationAbsorptionList;
1198 for (CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
1199 CConcept* opConcept = opConLinkerIt->getData();
1200 bool opNegated = opConLinkerIt->isNegated();
1201 if (!chooseInsteadOfNegation && operandsNegation) {
1202 opNegated = !opNegated;
1203 }
1204 TConceptNegPair conceptNegationPair(opConcept, opNegated);
1205
1206 if (!chooseInsteadOfNegation || operandsNegation == opNegated) {
1207 if (isConceptPropagationTriggerable(opConcept, opNegated)) {
1208 propagationAbsorptionList.append(conceptNegationPair);
1209 } else {
1210 backpropagationAbsorptionList.append(conceptNegationPair);
1211 }
1212 }
1213 }
1214
1215 CConceptTriggerLinker* propagationTriggers = nullptr;
1216 for (TConceptNegationPair conceptNegationPair : propagationAbsorptionList) {
1217 CConcept* opConcept = conceptNegationPair.first;
1218 bool opNegated = conceptNegationPair.second;
1219
1220 CConceptTriggerLinker* newTriggers = copyTriggerLinkers(getPropagationTriggersForConcept(opConcept, opNegated, intConceptNegationPair, completelyAbsorbable));
1221 propagationTriggers = newTriggers->append(propagationTriggers);
1222 }
1223
1224 CConceptTriggerLinker* implPropagationTriggeredConceptLinker = nullptr;
1225 if (propagationTriggers->hasNext()) {
1226 implPropagationTriggeredConceptLinker = getImplicationTriggeredConceptForTriggers(propagationTriggers, nullptr);
1227 } else {
1228 implPropagationTriggeredConceptLinker = propagationTriggers;
1229 }
1230 CConcept* backPropConcept = implPropagationTriggeredConceptLinker->getTriggerConcept();
1231
1232 CConceptTriggerLinker* backPropTriggers = implPropagationTriggeredConceptLinker;
1233 for (TConceptNegationPair conceptNegationPair : backpropagationAbsorptionList) {
1234 CConcept* opConcept = conceptNegationPair.first;
1235 bool opNegated = conceptNegationPair.second;
1236
1237 CConceptTriggerLinker* newTriggers = copyTriggerLinkers(getPartialTriggersForConcept(opConcept, opNegated, implPropagationTriggeredConceptLinker->getTriggerConcept()));
1238 backPropTriggers = newTriggers->append(backPropTriggers);
1239 }
1240
1241 if (backPropTriggers) {
1242 if (!backPropTriggers->hasNext()) {
1243 triggers = backPropTriggers;
1244 } else {
1245 triggers = getImplicationTriggeredConceptForTriggers(backPropTriggers, nullptr);
1246 }
1247 } else {
1248 triggers = implPropagationTriggeredConceptLinker;
1249 }
1250
1251 return triggers;
1252 }
1253
1254
1255
1256
1257 CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getPropagationTriggersForConcept(CConcept* concept, bool negated, TConceptNegPair& intConceptNegationPair, bool completelyAbsorbable) {
1258
1259 CConceptTriggerLinker* triggers = nullptr;
1260
1261
1262 TConceptNegationPair conNegPair(concept, negated);
1263
1264
1265 cint64 opCode = concept->getOperatorCode();
1266 cint64 parm = concept->getParameter();
1267 cint64 opCount = concept->getOperandCount();
1268 CRole* role = concept->getRole();
1269 CSortedNegLinker<CConcept*>* opConLinker = concept->getOperandList();
1270
1271 if (!negated && (opCode == CCNOMINAL)) {
1272
1273 CIndividual* nominalIndi = concept->getNominalIndividual();
1274 CConcept* individualActivationTriggerCon = createTriggerConcept(true);
1275
1276 CConceptOfInterestActivationTriggeringData& activationTriggeringData = mTBox->getConceptOfInterestActivationTriggerDataHash()->operator[](intConceptNegationPair);
1277 CConceptOfInterestActivationLinker* activationLinker = CObjectAllocator<CConceptOfInterestActivationLinker>::allocateAndConstruct(mMemMan);
1278 activationLinker->initConceptOfInterestActivationData(individualActivationTriggerCon, nominalIndi);
1279 activationTriggeringData.addActivationLinker(activationLinker);
1280
1281 CConceptTriggerLinker* newTrigger = createTriggerLinker();
1282 newTrigger->initConceptTriggerLinker(individualActivationTriggerCon, 1);
1283 triggers = newTrigger->append(triggers);
1284
1285 } else if (!negated && (opCode == CCVALUE)) {
1286
1287 CIndividual* nominalIndi = concept->getNominalIndividual();
1288 CRole* role = concept->getRole();
1289
1290 CConcept* propagatedTriggerConcept = createTriggerConcept(true);
1291 CConcept* individualActivationTriggerCon = createTriggerPropagationConcept(propagatedTriggerConcept, role, true);
1292
1293 CConceptOfInterestActivationTriggeringData& activationTriggeringData = mTBox->getConceptOfInterestActivationTriggerDataHash()->operator[](intConceptNegationPair);
1294 CConceptOfInterestActivationLinker* activationLinker = CObjectAllocator<CConceptOfInterestActivationLinker>::allocateAndConstruct(mMemMan);
1295 activationLinker->initConceptOfInterestActivationData(individualActivationTriggerCon, nominalIndi);
1296 activationTriggeringData.addActivationLinker(activationLinker);
1297
1298 CConceptTriggerLinker* newTrigger = createTriggerLinker();
1299 newTrigger->initConceptTriggerLinker(propagatedTriggerConcept, 2);
1300 triggers = newTrigger->append(triggers);
1301
1302 } else if (negated && (opCode == CCOR) || !negated && (opCode == CCAND)) {
1303 // AND, collect triggers from operands
1304 CConceptTriggerLinker* andTriggers = getPropagationTriggersForConceptOperandList(opConLinker, negated, false, concept, negated, intConceptNegationPair, completelyAbsorbable);
1305 triggers = andTriggers->append(triggers);
1306
1307 } else if (opCode == CCAQCHOOCE) {
1308
1309 CConceptTriggerLinker* andTriggers = getPropagationTriggersForConceptOperandList(opConLinker, negated, true, concept, negated, intConceptNegationPair, completelyAbsorbable);
1310 triggers = andTriggers->append(triggers);
1311
1312 } else if (!negated && (opCode == CCSOME || opCode == CCAQSOME) || negated && (opCode == CCALL) ||
1313 !negated && (opCode == CCATLEAST && parm == 1) || negated && (opCode == CCATMOST && parm == 0)) {
1314
1315 cint64 triggerComplexity = 1;
1316 bool negateOperands = negated && (opCode == CCSOME || opCode == CCALL);
1317
1318 CConceptTriggerLinker* succTriggers = getPropagationTriggersForConceptOperandList(opConLinker, negateOperands, false, concept, negated, intConceptNegationPair, completelyAbsorbable);
1319
1320 CConcept* rolePropagatedCon = createTriggerConcept(true);
1321 CConcept* rolePropagationCon = createTriggerPropagationConcept(rolePropagatedCon, role, true);
1322 addUnfoldingConceptForConcept(succTriggers->getTriggerConcept(), rolePropagationCon, false);
1323 triggerComplexity += succTriggers->getTriggerComplexity();
1324
1325 CConceptTriggerLinker* newTrigger = createTriggerLinker();
1326 newTrigger->initConceptTriggerLinker(rolePropagatedCon, triggerComplexity);
1327
1328 triggers = newTrigger->append(triggers);
1329 }
1330
1331 return triggers;
1332 }
1333
1334
1335
1336
1337 bool CTriggeredImplicationBinaryAbsorberPreProcess::createDirectConceptOfInterestAbsorption(CConcept* intConcept, bool negated, bool continuationExtension) {
1338 bool absorbed = false;
1339 CConcept* candidateBackPropTriggerCon = nullptr;
1340 QHash<CConcept*, TOccuredAbsorbablePair> conceptEqConAbsorbed;
1341 QSet<CConcept*> conceptEqConPartialAbsorbed;
1342 bool completlyAbsorbable = isConceptImplicationTriggerable(intConcept, negated, &conceptEqConAbsorbed);
1343 bool partiallyAbsorbable = completlyAbsorbable;
1344 if (!partiallyAbsorbable) {
1345 partiallyAbsorbable = isConceptPartialImplicationTriggerable(intConcept, negated, &conceptEqConPartialAbsorbed);
1346 }
1347 CConcept* markerConcept = nullptr;
1348 if (partiallyAbsorbable) {
1349 markerConcept = createMarkerConcept();
1350 }
1351
1352 CConceptOfInterestActivationTriggeringData& activationTriggeringData = mTBox->getConceptOfInterestActivationTriggerDataHash()->operator[](TConceptNegPair(intConcept, negated));
1353 if (continuationExtension && partiallyAbsorbable) {
1354 candidateBackPropTriggerCon = createTriggerConcept(true);
1355 CConceptOfInterestActivationLinker* activationLinker = CObjectAllocator<CConceptOfInterestActivationLinker>::allocateAndConstruct(mMemMan);
1356 activationLinker->initConceptOfInterestActivationData(candidateBackPropTriggerCon);
1357 activationTriggeringData.addActivationLinker(activationLinker);
1358 absorbed = true;
1359 }
1360 if (completlyAbsorbable) {
1361 CConcept* triggerConcept = getConceptOfInterestTrigger(intConcept, negated, candidateBackPropTriggerCon);
1362 addUnfoldingConceptForConcept(triggerConcept, markerConcept, false);
1363 mTBox->getTriggerConceptOfInterestHash()->insert(markerConcept, TConceptNegPair(intConcept, negated));
1364 activationTriggeringData.setTriggeringConcept(markerConcept);
1365 absorbed = true;
1366 } else if (partiallyAbsorbable) {
1367 CConcept* candidateConcept = getConceptOfInterestCandidate(intConcept, negated, candidateBackPropTriggerCon);
1368 addUnfoldingConceptForConcept(candidateConcept, markerConcept, false);
1369 activationTriggeringData.setCandidateConcept(markerConcept);
1370 mTBox->getCandidateConceptOfInterestHash()->insert(markerConcept, TConceptNegPair(intConcept, negated));
1371 absorbed = true;
1372 }
1373
1374 return absorbed;
1375 }
1376
1377
1378
1379
1380
1381 bool CTriggeredImplicationBinaryAbsorberPreProcess::isConceptPropagationTriggerable(CConcept* concept, bool negated) {
1382 TConceptNegationPair conNegPair(concept, negated);
1383 if (mConceptPropagationAbsorbableHash.contains(conNegPair)) {
1384 return mConceptPropagationAbsorbableHash.value(conNegPair);
1385 }
1386 cint64 opCode = concept->getOperatorCode();
1387 cint64 parm = concept->getParameter();
1388 cint64 opCount = concept->getOperandCount();
1389 CSortedNegLinker<CConcept*>* opConLinker = concept->getOperandList();
1390
1391 bool absorbable = false;
1392
1393 if (!negated && (opCode == CCNOMINAL)) {
1394 absorbable = true;
1395 } else if (!negated && (opCode == CCVALUE)) {
1396 absorbable = true;
1397 } else if (!negated && (opCode == CCSOME || opCode == CCAQSOME) || negated && (opCode == CCALL)) {
1398 if (!opConLinker) {
1399 absorbable = false;
1400 } else {
1401 bool oneOpTriggerable = false;
1402 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
1403 while (opConLinkerIt && !oneOpTriggerable) {
1404 CConcept* opConcept = opConLinkerIt->getData();
1405 bool opNegated = opConLinkerIt->isNegated() ^ negated;
1406 oneOpTriggerable |= isConceptPropagationTriggerable(opConcept, opNegated);
1407 opConLinkerIt = opConLinkerIt->getNext();
1408 }
1409 absorbable = oneOpTriggerable;
1410 }
1411 } else if (!negated && (opCode == CCATLEAST && parm == 1) || negated && (opCode == CCATMOST && parm == 0)) {
1412 if (!opConLinker) {
1413 absorbable = false;
1414 } else {
1415 bool oneOpTriggerable = true;
1416 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
1417 while (opConLinkerIt && !oneOpTriggerable) {
1418 CConcept* opConcept = opConLinkerIt->getData();
1419 bool opNegated = opConLinkerIt->isNegated();
1420 oneOpTriggerable |= isConceptPropagationTriggerable(opConcept, opNegated);
1421 opConLinkerIt = opConLinkerIt->getNext();
1422 }
1423 absorbable = oneOpTriggerable;
1424 }
1425 } else if (opCode == CCAQCHOOCE) {
1426 bool oneOpTriggerable = false;
1427 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
1428 while (opConLinkerIt && !oneOpTriggerable) {
1429 CConcept* opConcept = opConLinkerIt->getData();
1430 bool opNegated = opConLinkerIt->isNegated();
1431 if (opNegated == negated) {
1432 oneOpTriggerable |= isConceptPropagationTriggerable(opConcept, opNegated);
1433 }
1434 opConLinkerIt = opConLinkerIt->getNext();
1435 }
1436 absorbable = oneOpTriggerable;
1437 } else if (!negated && opCode == CCAND || negated && opCode == CCOR) {
1438 bool oneOpTriggerable = false;
1439 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
1440 while (opConLinkerIt && !oneOpTriggerable) {
1441 CConcept* opConcept = opConLinkerIt->getData();
1442 bool opNegated = opConLinkerIt->isNegated() ^ negated;
1443 oneOpTriggerable |= isConceptPropagationTriggerable(opConcept, opNegated);
1444 opConLinkerIt = opConLinkerIt->getNext();
1445 }
1446 absorbable = oneOpTriggerable;
1447 } else {
1448 absorbable = false;
1449 }
1450 mConceptPropagationAbsorbableHash.insert(conNegPair, absorbable);
1451 return absorbable;
1452 }
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createDisjunctionAbsorbedBackpropagationTriggeredImplication(CConcept* orConcept, bool negated, CConcept* backPropTriggerCon) {
1468 CConcept* implicationConcept = nullptr;
1469
1470 cint64 opCode = orConcept->getOperatorCode();
1471 if (!negated && opCode == CCOR || negated && opCode == CCAND) {
1472 QList<TConceptNegationPair> candList;
1473 if (addAbsorbableDisjunctCandidates(orConcept, negated, candList)) {
1474 if (candList.count() >= 1) {
1475 QList<TConceptNegationPair> absorbList(splitAbsorbableDisjuncts(candList));
1476 QList<TConceptNegationPair> partialAbsorbList(getPartialAbsorbableDisjuncts(candList));
1477 if (!absorbList.isEmpty() || !partialAbsorbList.isEmpty()) {
1478 implicationConcept = createDisjunctionAbsorbedBackpropagationTriggeredImplication(orConcept, negated, absorbList, partialAbsorbList, candList, backPropTriggerCon);
1479 }
1480 }
1481 }
1482 }
1483 return implicationConcept;
1484 }
1485
1486
1487
1488
1489 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createDisjunctionAbsorbedBackpropagationTriggeredImplication(CConcept* orConcept, bool negated, QList<TConceptNegationPair>& absorbList, QList<TConceptNegationPair>& partialAbsorbList, QList<TConceptNegationPair>& candList, CConcept* backPropTriggerCon) {
1490 CConcept* impliedConcept = nullptr;
1491 CConcept* implicationConcept = nullptr;
1492 bool impliedNegation = false;
1493
1494 if (candList.isEmpty()) {
1495 candList.append(absorbList.takeFirst());
1496 }
1497
1498 CConceptTriggerLinker* triggers = nullptr;
1499 for (QList<TConceptNegationPair>::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
1500 TConceptNegationPair conNegPair(*it);
1501 CConcept* concept = conNegPair.first;
1502 bool negated = conNegPair.second;
1503 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getTriggersForConcept(concept, !negated, backPropTriggerCon));
1504 triggers = tmpTriggers->append(triggers);
1505 }
1506 for (QList<TConceptNegationPair>::const_iterator it = partialAbsorbList.constBegin(), itEnd = partialAbsorbList.constEnd(); it != itEnd; ++it) {
1507 TConceptNegationPair conNegPair(*it);
1508 CConcept* concept = conNegPair.first;
1509 bool negated = conNegPair.second;
1510 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept, !negated, backPropTriggerCon));
1511 triggers = tmpTriggers->append(triggers);
1512 }
1513
1514 CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers, &implicationConcept);
1515 impliedConcept = impliedConceptTrigger->getTriggerConcept();
1516 if (candList.count() > 1) {
1517 CConcept* orImpliedConcept = createImpliedConcept();
1518 for (QList<TConceptNegationPair>::const_iterator it = candList.constBegin(), itEnd = candList.constEnd(); it != itEnd; ++it) {
1519 TConceptNegationPair conNegPair(*it);
1520 CConcept* concept = conNegPair.first;
1521 bool negated = conNegPair.second;
1522 addConceptToImplied(orImpliedConcept, concept, negated);
1523 }
1524 orImpliedConcept->setOperatorCode(CCOR);
1525 mCreatedImpliedDisjunctions.insert(orImpliedConcept);
1526 addUnfoldingConceptForConcept(impliedConcept, orImpliedConcept, false);
1527
1528 } else {
1529 TConceptNegationPair conNegPair(candList.first());
1530 CConcept* concept = conNegPair.first;
1531 bool negated = conNegPair.second;
1532 addUnfoldingConceptForConcept(impliedConcept, concept, negated);
1533 }
1534
1535 return implicationConcept;
1536 }
1537
1538
1539
1540
1541 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createPartialBackpropagationExtendedAbsorbedImpliedTriggerCocnept(const QList<TConceptNegationPair>& absorbList, CConcept* backPropTriggerCon) {
1542 CConceptTriggerLinker* trigger = createPartialBackpropagationExtendedAbsorbedImpliedTrigger(absorbList, backPropTriggerCon);
1543 if (trigger) {
1544 return trigger->getTriggerConcept();
1545 }
1546 return nullptr;
1547 }
1548
1549
1550 CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::createPartialBackpropagationExtendedAbsorbedImpliedTrigger(const QList<TConceptNegationPair>& absorbList, CConcept* backPropTriggerCon) {
1551 CConceptTriggerLinker* triggers = nullptr;
1552 for (QList<TConceptNegationPair>::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
1553 TConceptNegationPair conNegPair(*it);
1554 CConcept* concept = conNegPair.first;
1555 bool negated = conNegPair.second;
1556 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept, !negated, backPropTriggerCon));
1557 triggers = tmpTriggers->append(triggers);
1558 }
1559 CConcept* implicationConcept = nullptr;
1560 CConcept** implicationConceptPointer = nullptr;
1561 if (backPropTriggerCon) {
1562 implicationConceptPointer = &implicationConcept;
1563 }
1564 CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers, implicationConceptPointer);
1565 if (implicationConcept) {
1566 addUnfoldingConceptForConcept(backPropTriggerCon, implicationConcept, false);
1567 }
1568 return impliedConceptTrigger;
1569 }
1570
1571
1572 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::getConceptOfInterestCandidate(CConcept* intConcept, bool negated, CConcept* backPropTriggerCon) {
1573 CConcept* triggeredConcept = nullptr;
1574
1575 QList<TConceptNegationPair> candList;
1576 if (addAbsorbableDisjunctCandidates(intConcept, !negated, candList)) {
1577 if (candList.count() >= 1) {
1578 QList<TConceptNegationPair> absorbList(getPartialAbsorbableDisjuncts(candList));
1579 if (!absorbList.isEmpty()) {
1580 triggeredConcept = createBackpropPartialExtendedAbsorbedImpliedTrigger(absorbList, backPropTriggerCon)->getTriggerConcept();
1581 }
1582 }
1583 }
1584 return triggeredConcept;
1585 }
1586
1587
1588
1589
1590 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::getConceptOfInterestTrigger(CConcept* intConcept, bool negated, CConcept* backPropTriggerCon) {
1591 CConcept* triggeredConcept = nullptr;
1592
1593 QList<TConceptNegationPair> candList;
1594 if (addAbsorbableDisjunctCandidates(intConcept, !negated, candList)) {
1595 if (candList.count() >= 1) {
1596 QList<TConceptNegationPair> absorbList(splitAbsorbableDisjuncts(candList));
1597 if (!absorbList.isEmpty()) {
1598 triggeredConcept = createBackpropExtendedAbsorbedImpliedTrigger(absorbList, backPropTriggerCon)->getTriggerConcept();
1599 }
1600 }
1601 }
1602 return triggeredConcept;
1603 }
1604
1605
1606
1607 CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::createBackpropPartialExtendedAbsorbedImpliedTrigger(const QList<TConceptNegationPair>& absorbList, CConcept* backPropTriggerCon) {
1608 CConceptTriggerLinker* triggers = nullptr;
1609 for (QList<TConceptNegationPair>::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
1610 TConceptNegationPair conNegPair(*it);
1611 CConcept* concept = conNegPair.first;
1612 bool negated = conNegPair.second;
1613 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept, !negated, backPropTriggerCon));
1614 triggers = tmpTriggers->append(triggers);
1615 }
1616 CConcept* backPropImpConcept = nullptr;
1617 CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers, &backPropImpConcept);
1618 addUnfoldingConceptForConcept(backPropTriggerCon, backPropImpConcept, false);
1619 return impliedConceptTrigger;
1620 }
1621
1622
1623
1624
1625
1626 CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::createBackpropExtendedAbsorbedImpliedTrigger(const QList<TConceptNegationPair>& absorbList, CConcept* backPropTriggerCon) {
1627 CConceptTriggerLinker* triggers = nullptr;
1628 for (QList<TConceptNegationPair>::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
1629 TConceptNegationPair conNegPair(*it);
1630 CConcept* concept = conNegPair.first;
1631 bool negated = conNegPair.second;
1632 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getTriggersForConcept(concept, !negated, backPropTriggerCon));
1633 triggers = tmpTriggers->append(triggers);
1634 }
1635 CConcept* backPropImpConcept = nullptr;
1636 CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers, &backPropImpConcept);
1637 addUnfoldingConceptForConcept(backPropTriggerCon, backPropImpConcept, false);
1638 return impliedConceptTrigger;
1639 }
1640
1641
1642
1643
1644
1645
1646 bool CTriggeredImplicationBinaryAbsorberPreProcess::absorbPartialGCIConceptsToTriggeredImplications(CConcept* orConcept, bool negated) {
1647 cint64 opCode = orConcept->getOperatorCode();
1648 if (!negated && opCode == CCOR || negated && opCode == CCAND) {
1649 QList<TConceptNegationPair> candList;
1650 if (addAbsorbableDisjunctCandidates(orConcept,negated,candList)) {
1651 if (candList.count() >= 1) {
1652 QList<TConceptNegationPair> absorbList(getPartialAbsorbableDisjuncts(candList));
1653 if (!absorbList.isEmpty()) {
1654 createGCIPartialAbsorbedTriggeredImplication(orConcept,negated,absorbList);
1655
1656 if (absorbList.count() + 1 == candList.count()) {
1657 QList<TConceptNegationPair> assurList(getAssuringAbsorbableDisjuncts(absorbList));
1658 if (assurList.count() == absorbList.count()) {
1659 createGCIAssuringAbsorbedTriggeredImplication(orConcept, negated, assurList, candList);
1660 }
1661 }
1662
1663 return true;
1664 }
1665 }
1666 }
1667 }
1668 return false;
1669 }
1670
1671
1672
1673
1674
1675
1676
1677 void CTriggeredImplicationBinaryAbsorberPreProcess::createGCIAssuringAbsorbedTriggeredImplication(CConcept* orConcept, bool negated, const QList<TConceptNegationPair>& absorbList, const QList<TConceptNegationPair>& disjList) {
1678
1679
1680 CConcept* remainingDisConcept = nullptr;
1681 bool remainingDisConNegation = false;
1682
1683 QSet<TConceptNegationPair> absorbDisjSet = absorbList.toSet();
1684 for (TConceptNegationPair disConNegPair : disjList) {
1685 if (!absorbDisjSet.contains(disConNegPair)) {
1686 remainingDisConcept = disConNegPair.first;
1687 remainingDisConNegation = disConNegPair.second;
1688 break;
1689 }
1690 }
1691
1692 CConceptTriggerLinker* partialImpliedTrigger = createAssuringExtendedAbsorbedImpliedTrigger(absorbList);
1693 CConcept* partialImpliedTriggerConcept = partialImpliedTrigger->getTriggerConcept();
1694 addUnfoldingConceptForConcept(partialImpliedTriggerConcept, remainingDisConcept, remainingDisConNegation);
1695
1696 }
1697
1698
1699
1700
1701 CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::createAssuringExtendedAbsorbedImpliedTrigger(const QList<TConceptNegationPair>& absorbList) {
1702 CConceptTriggerLinker* triggers = nullptr;
1703 for (QList<TConceptNegationPair>::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
1704 TConceptNegationPair conNegPair(*it);
1705 CConcept* concept = conNegPair.first;
1706 bool negated = conNegPair.second;
1707 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getAssuringTriggersForConcept(concept, !negated));
1708 triggers = tmpTriggers->append(triggers);
1709 }
1710 CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers, nullptr);
1711 return impliedConceptTrigger;
1712 }
1713
1714
1715
1716 bool CTriggeredImplicationBinaryAbsorberPreProcess::absorbNominalSchemaGCIConceptsToTriggeredImplications(CConcept* concept, bool negated) {
1717
1718 if (concept->getOperatorCode() == CCNOMTEMPLREF) {
1719
1720 cint64 nomSchTemplIndex = concept->getParameter();
1721 CNominalSchemaTemplate* nsTemplate = mNomSchemaTemplVec->getData(nomSchTemplIndex);
1722
1723 if (nsTemplate) {
1724 CConcept* templConcept = nsTemplate->getTemplateConcept();
1725
1726 cint64 opCode = templConcept->getOperatorCode();
1727 if (!negated && opCode == CCOR || negated && opCode == CCAND) {
1728 QList<TConceptNegationPair> candList;
1729 if (addAbsorbableDisjunctCandidates(templConcept,negated,candList)) {
1730 if (candList.count() >= 1) {
1731 QList<TConceptNegationPair> absorbList(splitAbsorbableDisjuncts(candList));
1732 QList<TConceptNegationPair> partialAbsorbList(getPartialAbsorbableDisjuncts(candList));
1733 if (!absorbList.isEmpty() || !partialAbsorbList.isEmpty()) {
1734 createGCINominalSchemaAbsorbedTriggeredImplication(templConcept,negated,absorbList,partialAbsorbList,candList,nsTemplate);
1735 return true;
1736 }
1737 }
1738 }
1739 }
1740
1741 }
1742 }
1743 return false;
1744 }
1745
1746
1747
1748
1749
1750
1751
1752 bool CTriggeredImplicationBinaryAbsorberPreProcess::absorbNominalConceptsToAssertions(CConcept* orConcept, bool negated) {
1753 bool absorbed = false;
1754 cint64 opCode = orConcept->getOperatorCode();
1755 if (!negated && opCode == CCOR || negated && opCode == CCAND) {
1756
1757 if (orConcept->getOperandCount() == 2) {
1758 CConcept* nominalCon = orConcept->getOperandList()->getData();
1759 bool nominalConNeg = orConcept->getOperandList()->isNegated() ^ negated;
1760
1761 CConcept* impliedCon = orConcept->getOperandList()->getNext()->getData();
1762 bool impliedConNeg = orConcept->getOperandList()->getNext()->isNegated() ^ negated;
1763
1764
1765 if (!nominalConNeg || nominalCon->getOperatorCode() != CCNOMINAL) {
1766 CConcept* tmpCon = nominalCon;
1767 bool tmpConNeg = nominalConNeg;
1768
1769 nominalCon = impliedCon;
1770 nominalConNeg = impliedConNeg;
1771 impliedCon = tmpCon;
1772 impliedConNeg = tmpConNeg;
1773 }
1774
1775
1776 if (nominalConNeg && nominalCon->getOperatorCode() == CCNOMINAL) {
1777 CIndividual* nomIndi = nominalCon->getNominalIndividual();
1778
1779 cint64 impliedConCode = impliedCon->getOperatorCode();
1780 if (!impliedConNeg && impliedConCode == CCSOME && impliedCon->getOperandCount() == 1) {
1781
1782 CConcept* someQuantifiedCon = impliedCon->getOperandList()->getData();
1783 bool someQuantifiedConNeg = impliedCon->getOperandList()->isNegated() ^ impliedConNeg;
1784 cint64 someQuantifiedConCode = someQuantifiedCon->getOperatorCode();
1785
1786 if (!someQuantifiedConNeg && someQuantifiedConCode == CCNOMINAL) {
1787 absorbed = true;
1788 // absorb as role assertion
1789 CIndividual* connNomIndi = someQuantifiedCon->getNominalIndividual();
1790 CIndividual* locatedIndividual = CConceptRoleIndividualLocator::getLocatedIndividual(nomIndi, mOnto);
1791
1792 CRoleAssertionLinker* roleAssLinker = CObjectAllocator< CRoleAssertionLinker >::allocateAndConstruct(mMemMan);
1793 roleAssLinker->initRoleAssertionLinker(impliedCon->getRole(), connNomIndi);
1794 locatedIndividual->addAssertionRoleLinker(roleAssLinker);
1795 }
1796 }
1797
1798 if (!absorbed) {
1799 absorbed = true;
1800 // absorb as concept assertion
1801 CIndividual* locatedIndividual = CConceptRoleIndividualLocator::getLocatedIndividual(nomIndi, mOnto);
1802 CConceptAssertionLinker* assLinker = CObjectAllocator< CConceptAssertionLinker >::allocateAndConstruct(mMemMan);
1803 assLinker->initNegLinker(impliedCon, impliedConNeg);
1804 locatedIndividual->addAssertionConceptLinker(assLinker);
1805 }
1806
1807
1808 }
1809 }
1810
1811
1812 }
1813 return absorbed;
1814 }
1815
1816
1817 bool CTriggeredImplicationBinaryAbsorberPreProcess::absorbNegatedSelfToRoleDomain(CConcept* concept, bool negated) {
1818 bool absorbed = false;
1819 cint64 opCode = concept->getOperatorCode();
1820 if (negated && opCode == CCSELF) {
1821
1822 CRole* role = concept->getRole();
1823 CRole* locatedRole = CConceptRoleIndividualLocator::getLocatedRole(role, mOnto);
1824 CSortedNegLinker<CConcept*>* domainConLinker = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
1825 domainConLinker->init(concept, true);
1826 locatedRole->addDomainConceptLinker(domainConLinker);
1827
1828 absorbed = true;
1829 }
1830 return absorbed;
1831 }
1832
1833
1834
1835
1836
1837 void CTriggeredImplicationBinaryAbsorberPreProcess::createGCINominalSchemaAbsorbedTriggeredImplication(CConcept* orConcept, bool negated, QList<TConceptNegationPair>& absorbList, QList<TConceptNegationPair>& partialAbsorbList, QList<TConceptNegationPair>& candList, CNominalSchemaTemplate* nsTemplate) {
1838 CConcept* impliedConcept = nullptr;
1839 bool impliedNegation = false;
1840 QList<TConceptNegationPair> partialAbsorbableList;
1841
1842
1843 CConceptTriggerLinker* triggers = nullptr;
1844 for (QList<TConceptNegationPair>::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
1845 TConceptNegationPair conNegPair(*it);
1846 CConcept* concept = conNegPair.first;
1847 bool negated = conNegPair.second;
1848 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept,!negated));
1849 triggers = tmpTriggers->append(triggers);
1850 }
1851 for (QList<TConceptNegationPair>::const_iterator it = partialAbsorbList.constBegin(), itEnd = partialAbsorbList.constEnd(); it != itEnd; ++it) {
1852 TConceptNegationPair conNegPair(*it);
1853 CConcept* concept = conNegPair.first;
1854 bool negated = conNegPair.second;
1855 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept,!negated));
1856 triggers = tmpTriggers->append(triggers);
1857 }
1858 CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers,nullptr);
1859 impliedConcept = impliedConceptTrigger->getTriggerConcept();
1860
1861
1862 QList<TConceptNegationPair> absorpConceptList(absorbList);
1863 absorpConceptList.append(partialAbsorbList);
1864
1865 QSet<TConceptNegationPair> conceptSet;
1866 for (QList<TConceptNegationPair>::const_iterator it = absorpConceptList.constBegin(), itEnd = absorpConceptList.constEnd(); it != itEnd; ++it) {
1867 TConceptNegationPair conNegPair(*it);
1868 CConcept* operandConcept = conNegPair.first;
1869 bool operandConceptNegation = conNegPair.second;
1870 conceptSet.insert(TConceptNegationPair(operandConcept,!operandConceptNegation));
1871 }
1872
1873
1874 QHash<CConcept*,CVariable*> nomSchConceptVariableHash;
1875 CBOXSET<CConcept*>* nominalSchemasSet = nsTemplate->getNominalSchemaConceptSet();
1876 for (CBOXSET<CConcept*>::const_iterator it = nominalSchemasSet->constBegin(), itEnd = nominalSchemasSet->constEnd(); it != itEnd; ++it) {
1877 CConcept* nominalSchemaConcept = *it;
1878 CVariable* variable = CObjectAllocator< CVariable >::allocateAndConstruct(mMemMan);
1879 variable->initVariable(nominalSchemaConcept,mNextVariableID++);
1880 nomSchConceptVariableHash.insert(nominalSchemaConcept,variable);
1881 }
1882
1883 QList<TConceptNegationPair> groundConceptList(candList);
1884
1885 CConcept* nextAbsorptionConcept = impliedConcept;
1886
1887 bool pathPreabsorption = false;
1888 if (mConfNominalSchemaPathPreabsorption) {
1889 if (nominalSchemasSet->count() >= 3) {
1890 pathPreabsorption = true;
1891 }
1892 }
1893
1894 if (pathPreabsorption) {
1895 // create nominal schema absorption path
1896 CNominalSchemaAbsorptionPathLinker* absorptionPathLinker = new CNominalSchemaAbsorptionPathLinker();
1897 absorptionPathLinker->initNominalSchemaAbsorptionPathLinker(nullptr);
1898 absorptionPathLinker->setLastPathTriggerConcept(nextAbsorptionConcept);
1899
1900 absorptionPathLinker = getAbsorbedNominalSchemaPaths(conceptSet,absorptionPathLinker,&nomSchConceptVariableHash,nsTemplate);
1901 nextAbsorptionConcept = createBindingBackPropagationTriggerConcept();
1902
1903 for (CNominalSchemaAbsorptionPathLinker* absorptionPathLinkerIt = absorptionPathLinker; absorptionPathLinkerIt; absorptionPathLinkerIt = absorptionPathLinkerIt->getNext()) {
1904 CConcept* groundingConcept = nullptr;
1905 bool groundingConNegation = false;
1906 CNominalSchemaTemplate* grNSTemplate = nsTemplate;
1907 createBindingGroundConcept(groundingConcept,groundingConNegation,groundConceptList,grNSTemplate,CCPBINDGROUND);
1908 CConcept* lastPathTriggerConcept = absorptionPathLinkerIt->getLastPathTriggerConcept();
1909 addConceptOperand(lastPathTriggerConcept,groundingConcept,groundingConNegation);
1910
1911 addConceptOperand(groundingConcept,nextAbsorptionConcept,false);
1912 }
1913 } else {
1914
1915 CConcept* tmpNextAbsorptionConcept = createBindingBackPropagationActivationTriggerConcept();
1916 addConceptOperand(nextAbsorptionConcept,tmpNextAbsorptionConcept,false);
1917 nextAbsorptionConcept = tmpNextAbsorptionConcept;
1918
1919 }
1920
1921
1922 CNominalSchemaAbsorptionBranchLinker* absorptionBranchLinker = getAbsorbedJoinedNominalSchemaBranchLinker(conceptSet,nextAbsorptionConcept,&nomSchConceptVariableHash,nsTemplate);
1923
1924 for (CNominalSchemaAbsorptionBranchLinker* absorptionBranchLinkerIt = absorptionBranchLinker; absorptionBranchLinkerIt; absorptionBranchLinkerIt = absorptionBranchLinkerIt->getNext()) {
1925 CConcept* groundingConcept = nullptr;
1926 bool groundingConNegation = false;
1927 CNominalSchemaTemplate* grNSTemplate = nsTemplate;
1928 createBindingGroundConcept(groundingConcept,groundingConNegation,groundConceptList,grNSTemplate,CCVARBINDGROUND);
1929 CConcept* lastPathTriggerConcept = absorptionBranchLinkerIt->getLastBranchTriggerConcept();
1930 addConceptOperand(lastPathTriggerConcept,groundingConcept,groundingConNegation);
1931 }
1932
1933 }
1934
1935
1936
1937 void CTriggeredImplicationBinaryAbsorberPreProcess::createBindingGroundConcept(CConcept*& groundingConcept, bool& groundingConNegation, const QList<TConceptNegationPair>& groundConceptList, CNominalSchemaTemplate* nsTemplate, cint64 groundOpCode) {
1938 CConcept* groundConcept = nullptr;
1939 bool groundConNegation = false;
1940 bool createNewTemplate = false;
1941 if (groundConceptList.count() > 1) {
1942
1943 CConcept* orConcept = createNewConcept();
1944 orConcept->setOperatorCode(CCOR);
1945
1946
1947 for (QList<TConceptNegationPair>::const_iterator it = groundConceptList.constBegin(), itEnd = groundConceptList.constEnd(); it != itEnd; ++it) {
1948 TConceptNegationPair conNegPair(*it);
1949 CConcept* operandConcept = conNegPair.first;
1950 bool operandConceptNegation = conNegPair.second;
1951 addConceptOperand(orConcept,operandConcept,operandConceptNegation);
1952 }
1953
1954 groundConcept = orConcept;
1955 groundConNegation = false;
1956 createNewTemplate = true;
1957 } else if (groundConceptList.count() == 1) {
1958 TConceptNegationPair conNegPair(groundConceptList.first());
1959 groundConcept = conNegPair.first;
1960 groundConNegation = conNegPair.second;
1961 createNewTemplate = true;
1962 } else {
1963 groundConcept = mTopConcept;
1964 groundConNegation = true;
1965 }
1966
1967
1968 if (createNewTemplate) {
1969 nsTemplate = CObjectAllocator< CNominalSchemaTemplate >::allocateAndConstruct(mMemMan);
1970 CBOXSET<CConcept*>* nominalSchemaConceptSet = CObjectAllocator< CBOXSET<CConcept*> >::allocateAndConstruct(mMemMan);
1971 CBOXHASH<CConcept*,CConcept*>* conceptNominalSchemaConceptHash = CObjectAllocator< CBOXHASH<CConcept*,CConcept*> >::allocateAndConstruct(mMemMan);
1972 CBOXHASH<CConcept*,CConcept*>* absorbableConceptNominalSchemaConceptHash = CObjectAllocator< CBOXHASH<CConcept*,CConcept*> >::allocateAndConstruct(mMemMan);
1973 nsTemplate->initNominalSchemaTemplate(nominalSchemaConceptSet,conceptNominalSchemaConceptHash,absorbableConceptNominalSchemaConceptHash);
1974 if (!mNomSchemaTemplVec) {
1975 mNomSchemaTemplVec = mMBox->getNominalSchemaTemplateVector();
1976 }
1977 cint64 nextNomSchTemplID = mNomSchemaTemplVec->getItemCount();
1978 nsTemplate->setNominalSchemaTemplateTag(nextNomSchTemplID);
1979 mNomSchemaTemplVec->setData(nextNomSchTemplID,nsTemplate);
1980 nsTemplate->setTemplateConcept(groundConcept);
1981
1982
1983 collectNominalSchemaConcepts(groundConcept,nominalSchemaConceptSet);
1984 FOREACHIT (CConcept* nomSchConcept, *nominalSchemaConceptSet) {
1985 QSet<CConcept*> testedNomSchemConSet;
1986 hasNominalSchemaConceptFillHash(groundConcept,conceptNominalSchemaConceptHash,nomSchConcept,&testedNomSchemConSet);
1987 QSet<CConcept*> testedNomSchemAbsorbedConSet;
1988 hasNominalSchemaAbsorbableConceptFillHash(groundConcept,groundingConNegation,absorbableConceptNominalSchemaConceptHash,nomSchConcept,&testedNomSchemAbsorbedConSet);
1989 }
1990
1991 groundingConcept = createBindingGroundingConcept(nsTemplate,groundOpCode);
1992 } else {
1993 groundingConcept = groundConcept;
1994 }
1995 groundingConNegation = groundConNegation;
1996
1997 }
1998
1999 bool CTriggeredImplicationBinaryAbsorberPreProcess::hasNominalSchemaAbsorbableConceptFillHash(CConcept* concept, bool negation, CBOXHASH<CConcept*,CConcept*>* absorbableConceptNominalSchemaConceptHash, CConcept* nominalSchemaConcept, QSet<CConcept*>* testedConceptSet) {
2000 cint64 conOpCode = concept->getOperatorCode();
2001 if (conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM || concept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)) {
2002 return false;
2003 }
2004 bool foundAbsorbableNominalSchemaConcept = false;
2005
2006 if (negation && concept == nominalSchemaConcept) {
2007 foundAbsorbableNominalSchemaConcept = true;
2008 } else {
2009 cint64 conCode = concept->getOperatorCode();
2010 if (negation && (conCode == CCSOME) || !negation && (conCode == CCALL)) {
2011 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
2012 CConcept* opConcept = opConLinkerIt->getData();
2013 foundAbsorbableNominalSchemaConcept |= hasNominalSchemaAbsorbableConceptFillHash(opConcept,negation^opConLinkerIt->isNegated(),absorbableConceptNominalSchemaConceptHash,nominalSchemaConcept,testedConceptSet);
2014 }
2015 } else if (!negation && (conCode == CCAND || conCode == CCOR) || negation && (conCode == CCOR || conCode == CCAND)) {
2016 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
2017 CConcept* opConcept = opConLinkerIt->getData();
2018 foundAbsorbableNominalSchemaConcept |= hasNominalSchemaAbsorbableConceptFillHash(opConcept,negation^opConLinkerIt->isNegated(),absorbableConceptNominalSchemaConceptHash,nominalSchemaConcept,testedConceptSet);
2019 }
2020 }
2021 }
2022
2023 if (foundAbsorbableNominalSchemaConcept) {
2024 if (!testedConceptSet->contains(concept)) {
2025 testedConceptSet->insert(concept);
2026 absorbableConceptNominalSchemaConceptHash->insertMulti(concept,nominalSchemaConcept);
2027 }
2028 }
2029 return foundAbsorbableNominalSchemaConcept;
2030 }
2031
2032
2033
2034 bool CTriggeredImplicationBinaryAbsorberPreProcess::hasNominalSchemaConceptFillHash(CConcept* concept, CBOXHASH<CConcept*,CConcept*>* conceptNominalSchemaConceptHash, CConcept* nominalSchemaConcept, QSet<CConcept*>* testedConceptSet) {
2035 cint64 conOpCode = concept->getOperatorCode();
2036 if (conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM || concept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)) {
2037 return false;
2038 }
2039 bool foundNominalSchemaConcept = false;
2040
2041 if (concept == nominalSchemaConcept) {
2042 foundNominalSchemaConcept = true;
2043 } else {
2044 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
2045 CConcept* opConcept = opConLinkerIt->getData();
2046 foundNominalSchemaConcept |= hasNominalSchemaConceptFillHash(opConcept,conceptNominalSchemaConceptHash,nominalSchemaConcept,testedConceptSet);
2047 }
2048 }
2049
2050 if (foundNominalSchemaConcept) {
2051 if (!testedConceptSet->contains(concept)) {
2052 testedConceptSet->insert(concept);
2053 conceptNominalSchemaConceptHash->insertMulti(concept,nominalSchemaConcept);
2054 }
2055 }
2056 return foundNominalSchemaConcept;
2057 }
2058
2059
2060 void CTriggeredImplicationBinaryAbsorberPreProcess::collectNominalSchemaConcepts(CConcept* concept, CBOXSET<CConcept*>* nominalSchemaConceptSet) {
2061 cint64 conOpCode = concept->getOperatorCode();
2062 if (conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM || concept->getConceptOperator()->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)) {
2063 } else if (conOpCode == CCNOMVAR) {
2064 nominalSchemaConceptSet->insert(concept);
2065 } else {
2066 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
2067 CConcept* opConcept = opConLinkerIt->getData();
2068 collectNominalSchemaConcepts(opConcept,nominalSchemaConceptSet);
2069 }
2070 }
2071 }
2072
2073
2074 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingGroundingConcept(CNominalSchemaTemplate* nsTemplate, cint64 groundOpCode) {
2075 CConcept* groundingConcept = createNewConcept();
2076 groundingConcept->setOperatorCode(groundOpCode);
2077 groundingConcept->setParameter(nsTemplate->getNominalSchemaTemplateTag());
2078 return groundingConcept;
2079 }
2080
2081
2082
2083 CNominalSchemaAbsorptionPathLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getAbsorbedNominalSchemaPaths(const QSet<TConceptNegationPair>& conceptSet, CNominalSchemaAbsorptionPathLinker* absorptionPathLinker, QHash<CConcept*,CVariable*>* nomSchConceptVariableHash, CNominalSchemaTemplate* nsTemplate) {
2084
2085 CConceptTriggerLinker* triggers = nullptr;
2086
2087 QSet<CConcept*> conceptEqConAbsorbed;
2088 QSet<TConceptNegationPair> relatedConceptSet;
2089 for (QSet<TConceptNegationPair>::const_iterator it = conceptSet.constBegin(), itEnd = conceptSet.constEnd(); it != itEnd; ++it) {
2090 TConceptNegationPair conNegPair(*it);
2091 CConcept* concept = conNegPair.first;
2092 bool negated = conNegPair.second;
2093
2094 collectNominalSchemaRelatedConcepts(concept,negated,relatedConceptSet,nsTemplate);
2095
2096 isConceptPartialImplicationTriggerable(concept,negated,&conceptEqConAbsorbed);
2097 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept,negated));
2098 if (tmpTriggers) {
2099 triggers = tmpTriggers->append(triggers);
2100 }
2101 }
2102
2103 QList<TConceptNegationPair> nomSchConList;
2104 QList<TConceptNegationPair> otherConList;
2105 QList<TConceptNegationPair> orConList;
2106 sortNominalSchemaRelatedConcepts(relatedConceptSet,nsTemplate,nomSchConList,otherConList,orConList);
2107
2108 CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers,nullptr);
2109 CConcept* triggerConcept = impliedConceptTrigger->getTriggerConcept();
2110
2111
2112
2113 CNominalSchemaAbsorptionPathLinker* newAbsorptionPathLinker = nullptr;
2114
2115 CNominalSchemaAbsorptionPathLinker* absorptionPathLinkerIt = absorptionPathLinker;
2116 while (absorptionPathLinkerIt) {
2117 CNominalSchemaAbsorptionPathLinker* absorptionPath = absorptionPathLinkerIt;
2118 absorptionPathLinkerIt = absorptionPathLinkerIt->getNext();
2119 absorptionPath->clearNext();
2120
2121
2122 CConcept* lastPathTriggerConcept = absorptionPath->getLastPathTriggerConcept();
2123 QList<TConceptNegationPair> initNomSchConList;
2124 CConcept* levelTriggerConcept = nullptr;
2125
2126
2127 if (triggerConcept != lastPathTriggerConcept) {
2128 CConcept* nextPathTriggerConcept = createBindingTriggerConcept();
2129 CConcept* implicationConcept = createBindingImplicationTriggeredConcept(triggerConcept,nextPathTriggerConcept);
2130 addConceptOperand(lastPathTriggerConcept,implicationConcept,false);
2131 lastPathTriggerConcept = nextPathTriggerConcept;
2132 }
2133
2134
2135 // find already binded nominal schema variables
2136 QHash<CConcept*,CConcept*>* nomSchConTrigHash = absorptionPath->getNominalSchemaBindedConceptTriggerHash();
2137 for (QList<TConceptNegationPair>::const_iterator it = nomSchConList.constBegin(), itEnd = nomSchConList.constEnd(); it != itEnd; ++it) {
2138 TConceptNegationPair nomSchConNegPair(*it);
2139 CConcept* nomSchConcept = nomSchConNegPair.first;
2140
2141 CConcept* nominalBindConceptTrigger = nomSchConTrigHash->value(nomSchConcept,nullptr);
2142 if (nominalBindConceptTrigger) {
2143 CConcept* nextPathTriggerConcept = createBindingTriggerConcept();
2144 if (!levelTriggerConcept) {
2145 levelTriggerConcept = nominalBindConceptTrigger;
2146 }
2147
2148 CConcept* cycleCloseConcept = createBindingCycleCloseConcept(nominalBindConceptTrigger,nextPathTriggerConcept);
2149 addConceptOperand(lastPathTriggerConcept,cycleCloseConcept,false);
2150 lastPathTriggerConcept = nextPathTriggerConcept;
2151 } else {
2152 initNomSchConList.append(nomSchConNegPair);
2153 }
2154 }
2155
2156 //if (!levelTriggerConcept) {
2157 // levelTriggerConcept = createBindingTriggerConcept();
2158 // cint64 nextVariableID = 0;
2159 // if (absorptionPath->hasVariables()) {
2160 // nextVariableID = absorptionPath->getLastVariable()->getPathVariableID()+1;
2161 // }
2162 // CConcept* nominalConcept = nullptr;
2163 // if (!initNomSchConList.isEmpty()) {
2164 // TConceptNegationPair nomSchConNegPair(initNomSchConList.first());
2165 // CConcept* nomSchConcept = nomSchConNegPair.first;
2166 // nominalConcept = nomSchConcept;
2167 // }
2168 // CVariable* variable = CObjectAllocator< CVariable >::allocateAndConstruct(mMemMan);
2169 // variable->initVariable(nominalConcept,nextVariableID);
2170 // absorptionPath->addVariable(variable);
2171 // CConcept* varBindConcept = createBindingVariableConcept(levelTriggerConcept,variable);
2172 // addConceptOperand(lastPathTriggerConcept,varBindConcept,false);
2173 // lastPathTriggerConcept = levelTriggerConcept;
2174 //}
2175
2176 for (QList<TConceptNegationPair>::const_iterator it = initNomSchConList.constBegin(), itEnd = initNomSchConList.constEnd(); it != itEnd; ++it) {
2177 TConceptNegationPair nomSchConNegPair(*it);
2178 CConcept* nomSchConcept = nomSchConNegPair.first;
2179
2180 CConcept* nextTriggerConcept = createBindingTriggerConcept();
2181
2182 CVariable* variable = nomSchConceptVariableHash->value(nomSchConcept);
2183 absorptionPath->addVariable(variable);
2184 CConcept* varBindConcept = createBindingVariableConcept(nextTriggerConcept,variable);
2185 addConceptOperand(lastPathTriggerConcept,varBindConcept,false);
2186
2187 nomSchConTrigHash->insert(nomSchConcept,nextTriggerConcept);
2188 lastPathTriggerConcept = nextTriggerConcept;
2189
2190 if (!levelTriggerConcept) {
2191 levelTriggerConcept = nextTriggerConcept;
2192 }
2193 }
2194
2195 absorptionPath->setLastPathTriggerConcept(lastPathTriggerConcept);
2196
2197 // build absorption path recursive
2198 CNominalSchemaAbsorptionPathLinker* nextAbsorptionPathLinker = absorptionPath;
2199 for (QList<TConceptNegationPair>::const_iterator itRec = otherConList.constBegin(), itRecEnd = otherConList.constEnd(); itRec != itRecEnd; ++itRec) {
2200 TConceptNegationPair succConNegPair(*itRec);
2201 CConcept* succConcept = succConNegPair.first;
2202 bool succConNegation = succConNegPair.second;
2203 cint64 succConOpCode = succConcept->getOperatorCode();
2204 cint64 param = succConcept->getParameter();
2205
2206 if (!succConNegation && (succConOpCode == CCSOME || succConOpCode == CCATLEAST && param == 1) || succConNegation && (succConOpCode == CCALL || succConOpCode == CCATMOST && param == 0)) {
2207 CRole* role = succConcept->getRole();
2208 bool succOpNegate = succConOpCode == CCALL;
2209
2210 if (succConcept->getOperandList()) {
2211
2212 for (CNominalSchemaAbsorptionPathLinker* nextAbsorptionPathLinkerIt = nextAbsorptionPathLinker; nextAbsorptionPathLinkerIt; nextAbsorptionPathLinkerIt = nextAbsorptionPathLinkerIt->getNext()) {
2213 CConcept* nextAbsorptionPathTriggerConcept = createBindingTriggerConcept();
2214 CConcept* lastAbsorptionPathTriggerConcept = nextAbsorptionPathLinkerIt->getLastPathTriggerConcept();
2215 CConcept* propagationPathTriggerConcept = createBindingToSuccessorPropagationConcept(nextAbsorptionPathTriggerConcept,role);
2216 addConceptOperand(lastAbsorptionPathTriggerConcept,propagationPathTriggerConcept,false);
2217 nextAbsorptionPathLinkerIt->setLastPathTriggerConcept(nextAbsorptionPathTriggerConcept);
2218 }
2219
2220 QSet<TConceptNegationPair> operandConceptSet;
2221 for (CSortedNegLinker<CConcept*>* succOpConLinkerIt = succConcept->getOperandList(); succOpConLinkerIt; succOpConLinkerIt = succOpConLinkerIt->getNext()) {
2222 CConcept* succOpCon = succOpConLinkerIt->getData();
2223 bool succOpConNeg = succOpConLinkerIt->isNegated() ^ succOpNegate;
2224 operandConceptSet.insert(TConceptNegationPair(succOpCon,succOpConNeg));
2225 }
2226
2227 nextAbsorptionPathLinker = getAbsorbedNominalSchemaPaths(operandConceptSet,nextAbsorptionPathLinker,nomSchConceptVariableHash,nsTemplate);
2228
2229 for (CNominalSchemaAbsorptionPathLinker* nextAbsorptionPathLinkerIt = nextAbsorptionPathLinker; nextAbsorptionPathLinkerIt; nextAbsorptionPathLinkerIt = nextAbsorptionPathLinkerIt->getNext()) {
2230 CConcept* propNextAbsorptionPathTriggerConcept = createBindingTriggerConcept();
2231 CConcept* lastAbsorptionPathTriggerConcept = nextAbsorptionPathLinkerIt->getLastPathTriggerConcept();
2232 CConcept* propagationPathTriggerConcept = createBindingFromSuccessorPropagationConcept(propNextAbsorptionPathTriggerConcept,role);
2233 addConceptOperand(lastAbsorptionPathTriggerConcept,propagationPathTriggerConcept,false);
2234
2235 if (levelTriggerConcept) {
2236 CConcept* cylceNextAbsorptionPathTriggerConcept = createBindingTriggerConcept();
2237 CConcept* cycleCloseConcept = createBindingCycleCloseConcept(levelTriggerConcept,cylceNextAbsorptionPathTriggerConcept);
2238 addConceptOperand(propNextAbsorptionPathTriggerConcept,cycleCloseConcept,false);
2239
2240 nextAbsorptionPathLinkerIt->setLastPathTriggerConcept(cylceNextAbsorptionPathTriggerConcept);
2241 } else {
2242 nextAbsorptionPathLinkerIt->setLastPathTriggerConcept(propNextAbsorptionPathTriggerConcept);
2243 }
2244 }
2245 }
2246
2247 }
2248 }
2249
2250
2251 for (QList<TConceptNegationPair>::const_iterator itOr = orConList.constBegin(), itOrEnd = orConList.constEnd(); itOr != itOrEnd; ++itOr) {
2252 TConceptNegationPair orConNegPair(*itOr);
2253 CConcept* orConcept = orConNegPair.first;
2254 bool orConNegation = orConNegPair.second;
2255 cint64 orConOpCode = orConcept->getOperatorCode();
2256
2257 if (!orConNegation && (orConOpCode == CCOR) || orConNegation && (orConOpCode == CCAND)) {
2258
2259 cint64 opCount = orConcept->getOperandCount();
2260 if (opCount > 1) {
2261
2262 CNominalSchemaAbsorptionPathLinker* newNextAbsorptionPathLinker = nullptr;
2263
2264 CNominalSchemaAbsorptionPathLinker* nextAbsorptionPathLinkerIt = nextAbsorptionPathLinker;
2265 while (nextAbsorptionPathLinkerIt) {
2266 nextAbsorptionPathLinker = nextAbsorptionPathLinkerIt;
2267 nextAbsorptionPathLinkerIt = nextAbsorptionPathLinkerIt->getNext();
2268 nextAbsorptionPathLinker->clearNext();
2269
2270 CNominalSchemaAbsorptionPathLinker* dublicateAbsorptionPathLinkerIt = duplicateNominalSchemaAbsorptionPaths(nextAbsorptionPathLinker,opCount);
2271
2272 for (CSortedNegLinker<CConcept*>* orOpConLinkerIt = orConcept->getOperandList(); orOpConLinkerIt; orOpConLinkerIt = orOpConLinkerIt->getNext()) {
2273 CNominalSchemaAbsorptionPathLinker* dublicateAbsorptionPathLinker = dublicateAbsorptionPathLinkerIt;
2274 dublicateAbsorptionPathLinkerIt = dublicateAbsorptionPathLinkerIt->getNext();
2275 dublicateAbsorptionPathLinker->clearNext();
2276 CConcept* orOpCon = orOpConLinkerIt->getData();
2277 bool orOpConNeg = orOpConLinkerIt->isNegated();
2278
2279 QSet<TConceptNegationPair> operandConceptSet;
2280 operandConceptSet.insert(TConceptNegationPair(orOpCon,orOpConNeg));
2281 dublicateAbsorptionPathLinker = getAbsorbedNominalSchemaPaths(operandConceptSet,dublicateAbsorptionPathLinker,nomSchConceptVariableHash,nsTemplate);
2282
2283 newNextAbsorptionPathLinker = dublicateAbsorptionPathLinker->append(newNextAbsorptionPathLinker);
2284 }
2285
2286 }
2287
2288 nextAbsorptionPathLinker = newNextAbsorptionPathLinker;
2289
2290 }
2291 }
2292 }
2293
2294 newAbsorptionPathLinker = nextAbsorptionPathLinker->append(newAbsorptionPathLinker);
2295
2296
2297 }
2298
2299 return newAbsorptionPathLinker;
2300 }
2301
2302
2303
2304 CNominalSchemaAbsorptionPathLinker* CTriggeredImplicationBinaryAbsorberPreProcess::duplicateNominalSchemaAbsorptionPaths(CNominalSchemaAbsorptionPathLinker* abPathLinker, cint64 duplicateCount) {
2305 CNominalSchemaAbsorptionPathLinker* duplicateLinker = abPathLinker;
2306 for (cint64 i = 1; i < duplicateCount; ++i) {
2307 CNominalSchemaAbsorptionPathLinker* linker = new CNominalSchemaAbsorptionPathLinker();
2308 linker->initNominalSchemaAbsorptionPathLinker(abPathLinker);
2309 duplicateLinker = linker->append(duplicateLinker);
2310 }
2311 return duplicateLinker;
2312 }
2313
2314
2315
2316 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingToSuccessorPropagationConcept(CConcept* followingConcept, CRole* role) {
2317 CConcept* succPropConcept = createNewConcept();
2318 succPropConcept->setOperatorCode(CCPBINDALL);
2319 succPropConcept->setRole(role);
2320 addConceptOperand(succPropConcept,followingConcept,false);
2321 return succPropConcept;
2322 }
2323
2324 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingFromSuccessorPropagationConcept(CConcept* followingConcept, CRole* role) {
2325 CRole* inverseRole = getInverseRole(role);
2326 CConcept* succPropConcept = createNewConcept();
2327 succPropConcept->setOperatorCode(CCPBINDALL);
2328 succPropConcept->setRole(inverseRole);
2329 addConceptOperand(succPropConcept,followingConcept,false);
2330 return succPropConcept;
2331 }
2332
2333
2334 void CTriggeredImplicationBinaryAbsorberPreProcess::addConceptOperand(CConcept* concept, CConcept* operandConcept, bool operandNegation) {
2335 CSortedNegLinker<CConcept*>* newBaseOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
2336 newBaseOpCon->init(operandConcept,operandNegation,concept->getOperandList());
2337 concept->setOperandList(newBaseOpCon);
2338 concept->incOperandCount();
2339 }
2340
2341
2342
2343 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingTriggerConcept() {
2344 CConcept* triggConcept = createNewConcept();
2345 triggConcept->setOperatorCode(CCPBINDTRIG);
2346 return triggConcept;
2347 }
2348
2349
2350
2351
2352 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingImplicationTriggeredConcept(CConcept* triggeredConcept, CConcept* impliedConcept) {
2353 CConcept* implicationConcept = createNewConcept();
2354 implicationConcept->setOperatorCode(CCPBINDIMPL);
2355
2356 CSortedNegLinker<CConcept*>* newBaseOpCon1 = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
2357 newBaseOpCon1->init(triggeredConcept,true);
2358 CSortedNegLinker<CConcept*>* newBaseOpCon2 = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
2359 newBaseOpCon2->init(impliedConcept,false,newBaseOpCon1);
2360 implicationConcept->setOperandList(newBaseOpCon2);
2361 implicationConcept->incOperandCount(2);
2362
2363 return implicationConcept;
2364 }
2365
2366
2367
2368 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingCycleCloseConcept(CConcept* cycleCloseTriggerConcept, CConcept* impliedTriggerConcept) {
2369 CConcept* cycleConcept = createNewConcept();
2370 cycleConcept->setOperatorCode(CCPBINDCYCLE);
2371
2372 CSortedNegLinker<CConcept*>* newBaseOpCon1 = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
2373 newBaseOpCon1->init(cycleCloseTriggerConcept,true);
2374 CSortedNegLinker<CConcept*>* newBaseOpCon2 = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
2375 newBaseOpCon2->init(impliedTriggerConcept,false,newBaseOpCon1);
2376 cycleConcept->setOperandList(newBaseOpCon2);
2377 cycleConcept->incOperandCount(2);
2378
2379 return cycleConcept;
2380 }
2381
2382
2383 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingVariableConcept(CConcept* followingConcept, CVariable* variable) {
2384 CConcept* bindConcept = createNewConcept();
2385 bindConcept->setOperatorCode(CCPBINDVARIABLE);
2386 bindConcept->setVariableLinker(CObjectAllocator< CSortedLinker<CVariable*> >::allocateAndConstruct(mMemMan)->init(variable));
2387
2388 addConceptOperand(bindConcept,followingConcept,false);
2389
2390 return bindConcept;
2391 }
2392
2393
2394 void CTriggeredImplicationBinaryAbsorberPreProcess::sortNominalSchemaRelatedConcepts(QSet<TConceptNegationPair>& conceptSet, CNominalSchemaTemplate* nsTemplate, QList<TConceptNegationPair>& nomSchConList, QList<TConceptNegationPair>& otherConList, QList<TConceptNegationPair>& orConList) {
2395 for (QSet<TConceptNegationPair>::const_iterator it = conceptSet.constBegin(), itEnd = conceptSet.constEnd(); it != itEnd; ++it) {
2396 TConceptNegationPair conNegPair(*it);
2397 CConcept* concept = conNegPair.first;
2398 bool conNegation = conNegPair.second;
2399 cint64 opCode = concept->getOperatorCode();
2400 if (conNegation && (opCode == CCAND) || !conNegation && (opCode == CCOR)) {
2401 orConList.append(conNegPair);
2402 } else if (!conNegation && (opCode == CCNOMVAR)) {
2403 nomSchConList.append(conNegPair);
2404 } else {
2405 otherConList.append(conNegPair);
2406 }
2407 }
2408 }
2409
2410
2411 void CTriggeredImplicationBinaryAbsorberPreProcess::collectNominalSchemaRelatedConcepts(CConcept* concept, bool negated, QSet<TConceptNegationPair>& conceptSet, CNominalSchemaTemplate* nsTemplate) {
2412 CBOXHASH<CConcept*,CConcept*>* conceptNomSchemaAbsorbableConceptsHash = nsTemplate->getTemplateAbsorbableConceptNominalSchemaConceptHash();
2413 if (conceptNomSchemaAbsorbableConceptsHash->contains(concept)) {
2414 cint64 opCode = concept->getOperatorCode();
2415 if (!negated && (opCode == CCAND) || negated && (opCode == CCOR)) {
2416 for (CSortedNegLinker<CConcept*>* opLinkIt = concept->getOperandList(); opLinkIt; opLinkIt = opLinkIt->getNext()) {
2417 CConcept* opConcept = opLinkIt->getData();
2418 bool opConNegation = opLinkIt->isNegated() ^ negated;
2419 collectNominalSchemaRelatedConcepts(opConcept,opConNegation,conceptSet,nsTemplate);
2420 }
2421 } else {
2422 conceptSet.insert(TConceptNegationPair(concept,negated));
2423 }
2424 }
2425 }
2426
2427
2428
2429
2430
2431
2432
2433 CNominalSchemaAbsorptionBranchLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getAbsorbedJoinedNominalSchemaBranchLinker(CConcept* absorbingConcept, bool absorbingNegation, CConcept* backPropConTrigger, QHash<CConcept*,CVariable*>* nomSchConceptVariableHash, CNominalSchemaTemplate* nsTemplate) {
2434
2435 TConceptNegationPair absConNegPair(absorbingConcept,absorbingNegation);
2436 CNominalSchemaAbsorptionBranchLinker* abBranchLinker = mConceptNomSchAbsorpBranchLinkerHash.value(absConNegPair);
2437
2438 if (!abBranchLinker) {
2439 QSet<TConceptNegationPair> relatedConceptSet;
2440 relatedConceptSet.insert(TConceptNegationPair(absorbingConcept,absorbingNegation));
2441
2442 abBranchLinker = getAbsorbedJoinedNominalSchemaBranchLinker(relatedConceptSet,backPropConTrigger,nomSchConceptVariableHash,nsTemplate);
2443
2444 mConceptNomSchAbsorpBranchLinkerHash.insert(absConNegPair,abBranchLinker);
2445 }
2446 return abBranchLinker;
2447 }
2448
2449
2450
2451
2452 CNominalSchemaAbsorptionBranchLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getAbsorbedJoinedNominalSchemaBranchLinker(const QSet<TConceptNegationPair>& conceptSet, CConcept* backPropConTrigger, QHash<CConcept*,CVariable*>* nomSchConceptVariableHash, CNominalSchemaTemplate* nsTemplate) {
2453 CNominalSchemaAbsorptionBranchLinker* newAbLinker = nullptr;
2454
2455
2456 CConceptTriggerLinker* triggers = nullptr;
2457 QSet<TConceptNegationPair> relatedConceptSet;
2458 for (QSet<TConceptNegationPair>::const_iterator it = conceptSet.constBegin(), itEnd = conceptSet.constEnd(); it != itEnd; ++it) {
2459 TConceptNegationPair conNegPair(*it);
2460 CConcept* concept = conNegPair.first;
2461 bool negated = conNegPair.second;
2462 collectNominalSchemaRelatedConcepts(concept,negated,relatedConceptSet,nsTemplate);
2463 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept,negated));
2464 if (tmpTriggers) {
2465 triggers = tmpTriggers->append(triggers);
2466 }
2467 }
2468
2469 QList<TConceptNegationPair> nomSchConList;
2470 QList<TConceptNegationPair> otherConList;
2471 QList<TConceptNegationPair> orConList;
2472 sortNominalSchemaRelatedConcepts(relatedConceptSet,nsTemplate,nomSchConList,otherConList,orConList);
2473 QList<TConceptNegationPair> allConList(otherConList);
2474 allConList += nomSchConList;
2475 allConList += orConList;
2476
2477 CConcept* triggerConcept = nullptr;
2478 if (triggers) {
2479 CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers,nullptr);
2480 triggerConcept = impliedConceptTrigger->getTriggerConcept();
2481 }
2482
2483
2484 CConcept* activationTriggerConcept = nullptr;
2485 if (!activationTriggerConcept && mConfNominalSchemaBackPropagationMultiTrigger && mConfNominalSchemaBackPropagation) {
2486 CBackPropTrigHashData* backPropTrigHashData = nullptr;
2487 for (QList<TConceptNegationPair>::const_iterator nomSchIt = nomSchConList.constBegin(), nomSchItEnd = nomSchConList.constEnd(); nomSchIt != nomSchItEnd && !backPropTrigHashData; ++nomSchIt) {
2488 CConcept* nomSchCon = nomSchIt->first;
2489 backPropTrigHashData = mVarBackPropTrigHash.value(nomSchCon);
2490 }
2491 if (backPropTrigHashData) {
2492 activationTriggerConcept = backPropTrigHashData->mActivationTriggerConcept;
2493 if (triggerConcept) {
2494 addBindingBackPropagationTriggeredToImplicationConcept(backPropTrigHashData->mImplicationConcept,triggerConcept);
2495 }
2496 addBindingBackPropagationTriggeredToImplicationConcept(backPropTrigHashData->mImplicationConcept,backPropConTrigger);
2497 }
2498 }
2499 if (!activationTriggerConcept) {
2500 activationTriggerConcept = createBindingBackPropagationTriggerConcept();
2501 if (!mConfNominalSchemaBackPropagation && triggerConcept) {
2502 CConcept* tmpNextAbsorptionConcept = createBindingBackPropagationActivationTriggerConcept();
2503 addConceptOperand(triggerConcept,tmpNextAbsorptionConcept,false);
2504 addConceptOperand(tmpNextAbsorptionConcept,activationTriggerConcept,false);
2505 } else {
2506 if (!triggerConcept) {
2507 addConceptOperand(backPropConTrigger,activationTriggerConcept,false);
2508 } else {
2509 CConcept* implBindBackPropTrigCon = createBindingBackPropagationImplicationTriggeredConcept(triggerConcept,activationTriggerConcept);
2510 addConceptOperand(backPropConTrigger,implBindBackPropTrigCon,false);
2511 if (!nomSchConList.isEmpty() && mConfNominalSchemaBackPropagationMultiTrigger) {
2512 CBackPropTrigHashData* backPropTrigHashData = new CBackPropTrigHashData(activationTriggerConcept,implBindBackPropTrigCon);
2513 mVarBackPropTrigContainer.append(backPropTrigHashData);
2514 foreach (TConceptNegationPair conNegPair, nomSchConList) {
2515 CConcept* nomSchCon = conNegPair.first;
2516 mVarBackPropTrigHash.insert(nomSchCon,backPropTrigHashData);
2517 }
2518 }
2519 }
2520 }
2521 }
2522
2523
2524
2525 QList<CNominalSchemaAbsorptionBranchLinker*> newBranchConList;
2526 QList<CNominalSchemaAbsorptionBranchLinker*> newMultiBranchConList;
2527 QList<CNominalSchemaAbsorptionBranchLinker*> newSingleBranchConList;
2528
2529 for (QList<TConceptNegationPair>::const_iterator itRec = allConList.constBegin(), itRecEnd = allConList.constEnd(); itRec != itRecEnd; ++itRec) {
2530 TConceptNegationPair succConNegPair(*itRec);
2531 CConcept* succConcept = succConNegPair.first;
2532 bool succConNegation = succConNegPair.second;
2533 CNominalSchemaAbsorptionBranchLinker* newBranchLinker = getAbsorbedNominalSchemaBranchLinker(succConcept,succConNegation,activationTriggerConcept,nomSchConceptVariableHash,nsTemplate);
2534 if (newBranchLinker && newBranchLinker->hasNext()) {
2535 newMultiBranchConList.append(newBranchLinker);
2536 } else if (newBranchLinker) {
2537 newSingleBranchConList.append(newBranchLinker);
2538 }
2539 }
2540
2541 newBranchConList.append(newSingleBranchConList);
2542 newBranchConList.append(newMultiBranchConList);
2543
2544
2545
2546 QList<CNominalSchemaAbsorptionBranchLinker*> newBranchConItList;
2547 for (QList<CNominalSchemaAbsorptionBranchLinker*>::const_iterator it = newBranchConList.constBegin(), branchConListItEnd = newBranchConList.constEnd(); it != branchConListItEnd; ++it) {
2548 newBranchConItList.append(*it);
2549 }
2550 QList<CNominalSchemaAbsorptionBranchLinker*> orNewBranchConItList(newBranchConItList);
2551
2552
2553 QList< CNominalSchemaAbsorptionBranchLinker* >::iterator nextChangeEndIt = newBranchConItList.end();
2554
2555 bool iterationFinished = false;
2556 while (!iterationFinished) {
2557
2558
2559
2560 QList<CNominalSchemaAbsorptionBranchLinker*> aborpBranchList;
2561 for (QList<CNominalSchemaAbsorptionBranchLinker*>::const_iterator it = newBranchConItList.constBegin(), itEnd = newBranchConItList.constEnd(); it != itEnd; ++it) {
2562 aborpBranchList.append(*it);
2563 }
2564
2565 bool removedOne = true;
2566 while (removedOne) {
2567 removedOne = false;
2568 QList<CNominalSchemaAbsorptionBranchLinker*>::iterator it1 = aborpBranchList.begin();
2569 QList<CNominalSchemaAbsorptionBranchLinker*>::iterator it2 = it1;
2570 QList<CNominalSchemaAbsorptionBranchLinker*>::iterator itEnd = aborpBranchList.end();
2571 for (; it1 != itEnd && !removedOne; ++it1) {
2572 it2 = it1;
2573 for (++it2; it2 != itEnd && !removedOne; ++it2) {
2574 CNominalSchemaAbsorptionBranchLinker* abLinker1 = qMin(*it1,*it2);;
2575 CNominalSchemaAbsorptionBranchLinker* abLinker2 = qMax(*it1,*it2);;
2576
2577 TAbsorptionBranchPair absBranchPair(abLinker1,abLinker2);
2578 CNominalSchemaAbsorptionBranchLinker* newAbsBranchLinker = mAbsorptionBranchPairAbsorptionBranchHash.value(absBranchPair,nullptr);
2579 if (newAbsBranchLinker) {
2580 removedOne = true;
2581 aborpBranchList.removeOne(abLinker1);
2582 aborpBranchList.removeOne(abLinker2);
2583 aborpBranchList.append(newAbsBranchLinker);
2584
2585 CConcept* joiningConcept = newAbsBranchLinker->getBackPropagationBranchTriggerConcept();
2586 addConceptOperand(activationTriggerConcept,joiningConcept,false);
2587
2588 }
2589 }
2590 }
2591 }
2592
2593 CNominalSchemaAbsorptionBranchLinker* nextAbLinker = aborpBranchList.takeFirst();
2594 while (!aborpBranchList.isEmpty()) {
2595 CNominalSchemaAbsorptionBranchLinker* abLinker = aborpBranchList.takeFirst();
2596
2597 CConcept* branchTrigger1 = nextAbLinker->getLastBranchTriggerConcept();
2598 CConcept* branchTrigger2 = abLinker->getLastBranchTriggerConcept();
2599
2600 CConcept* newImpliedBranchTrigger = createVariableBindingPropagationTriggerConcept();
2601
2602 CConcept* joiningConcept = createVariableBindingPropagationJoiningConcept(branchTrigger1,branchTrigger2,newImpliedBranchTrigger);
2603 addConceptOperand(activationTriggerConcept,joiningConcept,false);
2604
2605 CNominalSchemaAbsorptionBranchLinker* newTmpAbLinker = new CNominalSchemaAbsorptionBranchLinker();
2606 newTmpAbLinker->joinNominalSchemaAbsorptionPathLinker(nextAbLinker,abLinker);
2607 newTmpAbLinker->setLastBranchTriggerConcept(newImpliedBranchTrigger);
2608 newTmpAbLinker->setBackPropagationBranchTriggerConcept(joiningConcept);
2609 createJoiningConceptVariableList(joiningConcept,nextAbLinker,abLinker);
2610
2611 TAbsorptionBranchPair absBranchPair(qMin(nextAbLinker,abLinker),qMax(nextAbLinker,abLinker));
2612 mAbsorptionBranchPairAbsorptionBranchHash.insert(absBranchPair,newTmpAbLinker);
2613
2614 nextAbLinker = newTmpAbLinker;
2615 }
2616
2617
2618 if (triggerConcept) {
2619 CConcept* nextVariableBindTrigger = createVariableBindingPropagationTriggerConcept();
2620 CConcept* varImplConcept = createVariableBindingPropagationImplicationTriggeredConcept(triggerConcept,nextVariableBindTrigger);
2621 CNominalSchemaAbsorptionBranchLinker* newTmpAbLinker = new CNominalSchemaAbsorptionBranchLinker();
2622 newTmpAbLinker->initNominalSchemaAbsorptionPathLinker(nextAbLinker);
2623 addConceptOperand(nextAbLinker->getLastBranchTriggerConcept(),varImplConcept,false);
2624 newTmpAbLinker->setLastBranchTriggerConcept(nextVariableBindTrigger);
2625 newTmpAbLinker->setBackPropagationBranchTriggerConcept(activationTriggerConcept);
2626 nextAbLinker = newTmpAbLinker;
2627 }
2628
2629 newAbLinker = nextAbLinker->append(newAbLinker);
2630
2631
2632
2633 QList< CNominalSchemaAbsorptionBranchLinker* >::iterator nextChangeIt = newBranchConItList.begin();
2634 QList< CNominalSchemaAbsorptionBranchLinker* >::iterator nextOriginalIt = orNewBranchConItList.begin();
2635 CNominalSchemaAbsorptionBranchLinker* nomSchAbsBranchLinkerIt = *nextChangeIt;
2636
2637 nomSchAbsBranchLinkerIt = nomSchAbsBranchLinkerIt->getNext();
2638 bool continueIteration = true;
2639
2640 while (!nomSchAbsBranchLinkerIt && !iterationFinished) {
2641 continueIteration = false;
2642
2643 *nextChangeIt = *nextOriginalIt;
2644
2645 ++nextChangeIt;
2646 ++nextOriginalIt;
2647
2648 if (nextChangeIt == nextChangeEndIt) {
2649 iterationFinished = true;
2650 } else {
2651 nomSchAbsBranchLinkerIt = *nextChangeIt;
2652 nomSchAbsBranchLinkerIt = nomSchAbsBranchLinkerIt->getNext();
2653 if (!nomSchAbsBranchLinkerIt) {
2654 continueIteration = true;
2655 }
2656 }
2657 }
2658 if (!iterationFinished) {
2659 *nextChangeIt = nomSchAbsBranchLinkerIt;
2660 }
2661
2662 }
2663
2664
2665 return newAbLinker;
2666 }
2667
2668
2669
2670
2671 CNominalSchemaAbsorptionBranchLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getAbsorbedNominalSchemaBranchLinker(CConcept* absorbingConcept, bool absorbingNegation, CConcept* backPropConTrigger, QHash<CConcept*,CVariable*>* nomSchConceptVariableHash, CNominalSchemaTemplate* nsTemplate) {
2672 CNominalSchemaAbsorptionBranchLinker* newBranchLinker = nullptr;
2673
2674 TConceptNegationPair absConNegPair(absorbingConcept,absorbingNegation);
2675 newBranchLinker = mConceptNomSchAbsorpBranchLinkerHash.value(absConNegPair);
2676
2677 if (!newBranchLinker) {
2678 cint64 absConOpCode = absorbingConcept->getOperatorCode();
2679 cint64 param = absorbingConcept->getParameter();
2680
2681 if (!absorbingNegation && (absConOpCode == CCSOME || absConOpCode == CCATLEAST && param == 1) || absorbingNegation && (absConOpCode == CCALL || absConOpCode == CCATMOST && param == 0)) {
2682 CRole* role = absorbingConcept->getRole();
2683 bool succOpNegate = absConOpCode == CCALL;
2684
2685 if (absorbingConcept->getOperandList()) {
2686
2687 CConcept* nextAbsorptionBranchTriggerConcept = createBindingBackPropagationTriggerConcept();
2688 CConcept* propagationPathTriggerConcept = createBindingBackPropagationToSuccessorConcept(nextAbsorptionBranchTriggerConcept,role);
2689 addConceptOperand(backPropConTrigger,propagationPathTriggerConcept,false);
2690
2691
2692 QSet<TConceptNegationPair> operandConceptSet;
2693 for (CSortedNegLinker<CConcept*>* succOpConLinkerIt = absorbingConcept->getOperandList(); succOpConLinkerIt; succOpConLinkerIt = succOpConLinkerIt->getNext()) {
2694 CConcept* succOpCon = succOpConLinkerIt->getData();
2695 bool succOpConNeg = succOpConLinkerIt->isNegated() ^ succOpNegate;
2696 operandConceptSet.insert(TConceptNegationPair(succOpCon,succOpConNeg));
2697 }
2698
2699 CNominalSchemaAbsorptionBranchLinker* nextAbsorptionBranchLinker = getAbsorbedJoinedNominalSchemaBranchLinker(operandConceptSet,nextAbsorptionBranchTriggerConcept,nomSchConceptVariableHash,nsTemplate);
2700
2701 for (CNominalSchemaAbsorptionBranchLinker* nextAbsorptionBranchLinkerIt = nextAbsorptionBranchLinker; nextAbsorptionBranchLinkerIt; nextAbsorptionBranchLinkerIt = nextAbsorptionBranchLinkerIt->getNext()) {
2702
2703 CNominalSchemaAbsorptionBranchLinker* tmpNewAbsBranchLinker = new CNominalSchemaAbsorptionBranchLinker();
2704 tmpNewAbsBranchLinker->initNominalSchemaAbsorptionPathLinker(nextAbsorptionBranchLinkerIt);
2705
2706 tmpNewAbsBranchLinker->setBackPropagationBranchTriggerConcept(propagationPathTriggerConcept);
2707
2708 CConcept* nextVariableBindPropTriggerConcept = createVariableBindingPropagationTriggerConcept();
2709 CConcept* propagationVariableBindPropConcept = createVariableBindingPropagationFromSuccessorConcept(nextVariableBindPropTriggerConcept,role);
2710 CConcept* lastVariableBindPropTriggerConcept = tmpNewAbsBranchLinker->getLastBranchTriggerConcept();
2711 addConceptOperand(lastVariableBindPropTriggerConcept,propagationVariableBindPropConcept,false);
2712 tmpNewAbsBranchLinker->setLastBranchTriggerConcept(nextVariableBindPropTriggerConcept);
2713
2714 newBranchLinker = tmpNewAbsBranchLinker->append(newBranchLinker);
2715 }
2716 }
2717
2718 } else if (!absorbingNegation && (absConOpCode == CCOR) || absorbingNegation && (absConOpCode == CCAND)) {
2719
2720 for (CSortedNegLinker<CConcept*>* opConLinkerIt = absorbingConcept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
2721 CConcept* opCon = opConLinkerIt->getData();
2722 bool opConNeg = opConLinkerIt->isNegated() ^ absorbingNegation;
2723
2724 CNominalSchemaAbsorptionBranchLinker* tmpNewAbsBranchLinker = getAbsorbedJoinedNominalSchemaBranchLinker(opCon,opConNeg,backPropConTrigger,nomSchConceptVariableHash,nsTemplate);
2725 newBranchLinker = tmpNewAbsBranchLinker->append(newBranchLinker);
2726 }
2727
2728 } else if (!absorbingNegation && (absConOpCode == CCNOMVAR)) {
2729 CVariable* variable = nomSchConceptVariableHash->value(absorbingConcept,nullptr);
2730 if (!variable) {
2731 variable = CObjectAllocator< CVariable >::allocateAndConstruct(mMemMan);
2732 variable->initVariable(absorbingConcept,mNextVariableID++);
2733 nomSchConceptVariableHash->insert(absorbingConcept,variable);
2734 }
2735
2736 CConcept* varBindTriggerConcept = createVariableBindingPropagationTriggerConcept();
2737 CConcept* bindVarConcept = createVariableBindingPropagationBindVariableConcept(varBindTriggerConcept,variable);
2738 CNominalSchemaAbsorptionBranchLinker* newAbsBranchLinker = new CNominalSchemaAbsorptionBranchLinker();
2739 newAbsBranchLinker->initNominalSchemaAbsorptionPathLinker(nullptr);
2740 newAbsBranchLinker->setLastBranchTriggerConcept(varBindTriggerConcept);
2741 newAbsBranchLinker->setBackPropagationBranchTriggerConcept(bindVarConcept);
2742 newAbsBranchLinker->addVariable(variable);
2743 if (!mConfNominalSchemaBackPropagation) {
2744 CConcept* nominalTriggerConcept = mTBox->getIndividualTriggerConcept();
2745 CConcept* tmpNextAbsorptionConcept = createBindingBackPropagationActivationTriggerConcept();
2746 addConceptOperand(nominalTriggerConcept,tmpNextAbsorptionConcept,false);
2747 addConceptOperand(tmpNextAbsorptionConcept,bindVarConcept,false);
2748 } else {
2749 addConceptOperand(backPropConTrigger,bindVarConcept,false);
2750 }
2751
2752 newBranchLinker = newAbsBranchLinker;
2753 }
2754
2755 mConceptNomSchAbsorpBranchLinkerHash.insert(absConNegPair,newBranchLinker);
2756 } else {
2757 for (CNominalSchemaAbsorptionBranchLinker* nextAbsorptionBranchLinkerIt = newBranchLinker; nextAbsorptionBranchLinkerIt; nextAbsorptionBranchLinkerIt = nextAbsorptionBranchLinkerIt->getNext()) {
2758 addConceptOperand(backPropConTrigger,nextAbsorptionBranchLinkerIt->getBackPropagationBranchTriggerConcept(),false);
2759 }
2760 }
2761
2762 return newBranchLinker;
2763 }
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createVariableBindingPropagationBindVariableConcept(CConcept* followingConcept, CVariable* variable) {
2780 CConcept* bindConcept = createNewConcept();
2781 bindConcept->setOperatorCode(CCVARBINDVARIABLE);
2782 bindConcept->setVariableLinker(CObjectAllocator< CSortedLinker<CVariable*> >::allocateAndConstruct(mMemMan)->init(variable));
2783
2784 addConceptOperand(bindConcept,followingConcept,false);
2785
2786 return bindConcept;
2787 }
2788
2789
2790
2791 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingBackPropagationActivationTriggerConcept() {
2792 CConcept* triggConcept = createNewConcept();
2793 triggConcept->setOperatorCode(CCBACKACTIVTRIG);
2794 return triggConcept;
2795 }
2796
2797 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingBackPropagationTriggerConcept() {
2798 CConcept* triggConcept = createNewConcept();
2799 triggConcept->setOperatorCode(CCVARPBACKTRIG);
2800 return triggConcept;
2801 }
2802
2803
2804 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingBackPropagationToSuccessorConcept(CConcept* followingConcept, CRole* role) {
2805 CConcept* succPropConcept = createNewConcept();
2806 succPropConcept->setOperatorCode(CCVARPBACKALL);
2807 succPropConcept->setRole(role);
2808 addConceptOperand(succPropConcept,followingConcept,false);
2809 return succPropConcept;
2810 }
2811
2812 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createVariableBindingPropagationFromSuccessorConcept(CConcept* followingConcept, CRole* role) {
2813 CRole* inverseRole = getInverseRole(role);
2814 CConcept* succPropConcept = createNewConcept();
2815 succPropConcept->setOperatorCode(CCVARBINDALL);
2816 succPropConcept->setRole(inverseRole);
2817 addConceptOperand(succPropConcept,followingConcept,false);
2818 return succPropConcept;
2819 }
2820
2821
2822
2823 bool CTriggeredImplicationBinaryAbsorberPreProcess::addBindingBackPropagationTriggeredToImplicationConcept(CConcept* implicationConcept, CConcept* triggeredConcept) {
2824 CSortedNegLinker<CConcept*>* lastOpConLinker = nullptr;
2825 for (CSortedNegLinker<CConcept*>* opConLinker = implicationConcept->getOperandList(); opConLinker; opConLinker = opConLinker->getNext()) {
2826 lastOpConLinker = opConLinker;
2827 if (lastOpConLinker->getData() == triggeredConcept) {
2828 return false;
2829 }
2830 }
2831 CSortedNegLinker<CConcept*>* newBaseOpCon1 = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
2832 newBaseOpCon1->init(triggeredConcept,true);
2833 lastOpConLinker->setNext(newBaseOpCon1);
2834 implicationConcept->incOperandCount();
2835 return true;
2836 }
2837
2838
2839
2840 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createBindingBackPropagationImplicationTriggeredConcept(CConcept* triggeredConcept, CConcept* impliedConcept) {
2841 CConcept* implicationConcept = createNewConcept();
2842 implicationConcept->setOperatorCode(CCBACKACTIVIMPL);
2843
2844 CSortedNegLinker<CConcept*>* newBaseOpCon1 = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
2845 newBaseOpCon1->init(triggeredConcept,true);
2846 CSortedNegLinker<CConcept*>* newBaseOpCon2 = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
2847 newBaseOpCon2->init(impliedConcept,false,newBaseOpCon1);
2848 implicationConcept->setOperandList(newBaseOpCon2);
2849 implicationConcept->incOperandCount(2);
2850
2851 return implicationConcept;
2852 }
2853
2854
2855 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createVariableBindingPropagationImplicationTriggeredConcept(CConcept* triggeredConcept, CConcept* impliedConcept) {
2856 CConcept* implicationConcept = createNewConcept();
2857 implicationConcept->setOperatorCode(CCVARBINDIMPL);
2858
2859 CSortedNegLinker<CConcept*>* newBaseOpCon1 = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
2860 newBaseOpCon1->init(triggeredConcept,true);
2861 CSortedNegLinker<CConcept*>* newBaseOpCon2 = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
2862 newBaseOpCon2->init(impliedConcept,false,newBaseOpCon1);
2863 implicationConcept->setOperandList(newBaseOpCon2);
2864 implicationConcept->incOperandCount(2);
2865
2866 return implicationConcept;
2867 }
2868
2869
2870 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createVariableBindingPropagationTriggerConcept() {
2871 CConcept* triggConcept = createNewConcept();
2872 triggConcept->setOperatorCode(CCVARBINDTRIG);
2873 return triggConcept;
2874 }
2875
2876
2877
2878
2879 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createVariableBindingPropagationJoiningConcept(CConcept* joinConcept1, CConcept* joinConcept2, CConcept* impliedConcept) {
2880 CConcept* joiningConcept = createNewConcept();
2881 joiningConcept->setOperatorCode(CCVARBINDJOIN);
2882
2883 CSortedNegLinker<CConcept*>* newBaseOpCon1 = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
2884 newBaseOpCon1->init(joinConcept2,true);
2885 CSortedNegLinker<CConcept*>* newBaseOpCon2 = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
2886 newBaseOpCon2->init(joinConcept1,true,newBaseOpCon1);
2887 CSortedNegLinker<CConcept*>* newBaseOpCon3 = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
2888 newBaseOpCon3->init(impliedConcept,false,newBaseOpCon2);
2889 joiningConcept->setOperandList(newBaseOpCon3);
2890 joiningConcept->incOperandCount(3);
2891
2892 return joiningConcept;
2893 }
2894
2895
2896 void CTriggeredImplicationBinaryAbsorberPreProcess::createJoiningConceptVariableList(CConcept* joiningConcept, CNominalSchemaAbsorptionBranchLinker* abLinker1, CNominalSchemaAbsorptionBranchLinker* abLinker2) {
2897 QSet<CVariable*>* varSet1 = abLinker1->getVariableSet();
2898 QSet<CVariable*>* varSet2 = abLinker2->getVariableSet();
2899 CSortedLinker<CVariable*>* varLinker = nullptr;
2900 for (QSet<CVariable*>::const_iterator it = varSet1->constBegin(), itEnd = varSet1->constEnd(); it != itEnd; ++it) {
2901 if (varSet2->contains(*it)) {
2902 CVariable* variable = *it;
2903 CSortedLinker<CVariable*>* tmpVarLinker = CObjectAllocator< CSortedLinker<CVariable*> >::allocateAndConstruct(mMemMan);
2904 tmpVarLinker->init(variable);
2905 if (varLinker) {
2906 varLinker = varLinker->insertNextSorted(tmpVarLinker);
2907 } else {
2908 varLinker = tmpVarLinker;
2909 }
2910 }
2911 }
2912 joiningConcept->setVariableLinker(varLinker);
2913 }
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924 void CTriggeredImplicationBinaryAbsorberPreProcess::createGCIPartialAbsorbedTriggeredImplication(CConcept* orConcept, bool negated, const QList<TConceptNegationPair>& absorbList) {
2925 //CConceptRoleBranchingTrigger* branchTriggers = nullptr;
2926 //for (QList<TConceptNegationPair>::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
2927 // TConceptNegationPair conNegPair(*it);
2928 // CConcept* concept = conNegPair.first;
2929 // bool negated = conNegPair.second;
2930 // CConceptRoleBranchingTrigger* tmpBranchTrigger = getSimpleBranchTriggersForConcept(concept,!negated);
2931 // if (tmpBranchTrigger) {
2932 // branchTriggers = tmpBranchTrigger->append(branchTriggers);
2933 // } else {
2934 // CConceptRoleBranchingTrigger* tmpBranchTrigger = getBranchTiggers(getPartialTriggersForConcept(concept,!negated));
2935 // branchTriggers = tmpBranchTrigger->append(branchTriggers);
2936 // }
2937 //}
2938 CConceptTriggerLinker* partialImpliedTrigger = createPartialExtendedAbsorbedImpliedTrigger(absorbList);
2939 CConcept* partialImpliedTriggerConcept = partialImpliedTrigger->getTriggerConcept();
2940 addUnfoldingConceptForConcept(partialImpliedTriggerConcept,orConcept,negated);
2941
2942 CConceptRoleBranchingTrigger* branchTriggers = getSimpleBranchTriggersForConcept(partialImpliedTriggerConcept,true);
2943 mBranchTriggVec->setData(orConcept->getConceptTag(),branchTriggers);
2944 }
2945
2946
2947
2948 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createDisjunctionAbsorbedTriggeredImplication(CConcept* orConcept, bool negated, QList<TConceptNegationPair>& absorbList, QList<TConceptNegationPair>& candList) {
2949 CConcept* impliedConcept = nullptr;
2950 CConcept* implicationConcept = nullptr;
2951 bool impliedNegation = false;
2952
2953 if (candList.isEmpty()) {
2954 candList.append(absorbList.takeFirst());
2955 }
2956
2957 CConceptTriggerLinker* triggers = nullptr;
2958 for (QList<TConceptNegationPair>::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
2959 TConceptNegationPair conNegPair(*it);
2960 CConcept* concept = conNegPair.first;
2961 bool negated = conNegPair.second;
2962 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getTriggersForConcept(concept,!negated));
2963 triggers = tmpTriggers->append(triggers);
2964 }
2965 CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers,&implicationConcept);
2966 impliedConcept = impliedConceptTrigger->getTriggerConcept();
2967 if (candList.count() > 1) {
2968 CConcept* orImpliedConcept = createImpliedConcept();
2969 for (QList<TConceptNegationPair>::const_iterator it = candList.constBegin(), itEnd = candList.constEnd(); it != itEnd; ++it) {
2970 TConceptNegationPair conNegPair(*it);
2971 CConcept* concept = conNegPair.first;
2972 bool negated = conNegPair.second;
2973 addConceptToImplied(orImpliedConcept,concept,negated);
2974 }
2975 orImpliedConcept->setOperatorCode(CCOR);
2976 addUnfoldingConceptForConcept(impliedConcept,orImpliedConcept,false);
2977
2978 if (mConfPartialDisjunctionsAbsorption) {
2979 QList<TConceptNegationPair> partialAbsorbableList;
2980 partialAbsorbableList = getPartialAbsorbableDisjuncts(candList);
2981 if (!partialAbsorbableList.isEmpty()) {
2982 CConcept* partialImpliedTriggerConcept = createPartialExtendedAbsorbedImpliedTriggerCocnept(partialAbsorbableList);
2983 CConceptRoleBranchingTrigger* branchTriggers = getSimpleBranchTriggersForConcept(partialImpliedTriggerConcept,true);
2984 mBranchTriggVec->setData(impliedConcept->getConceptTag(),branchTriggers);
2985 ++mStatGCIAbsorptionPartialExtended;
2986 }
2987 }
2988 } else {
2989 TConceptNegationPair conNegPair(candList.first());
2990 CConcept* concept = conNegPair.first;
2991 bool negated = conNegPair.second;
2992 addUnfoldingConceptForConcept(impliedConcept,concept,negated);
2993 }
2994
2995 return implicationConcept;
2996 }
2997
2998
2999
3000
3001
3002 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::getRoleDomainTriggerConcept(CRole* role) {
3003 if (!mRoleDomainTriggerConceptHash) {
3004 mRoleDomainTriggerConceptHash = mTBox->getRoleDomainTriggerConceptHash(true);
3005 }
3006 CConcept*& triggerConcept = (*mRoleDomainTriggerConceptHash)[role];
3007 if (!triggerConcept) {
3008 triggerConcept = createTriggerConcept();
3009 addRoleDomainConcept(role,triggerConcept,false);
3010 }
3011 return triggerConcept;
3012 }
3013
3014
3015
3016
3017
3018
3019
3020 CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getTriggersForConcept(CConcept* concept, bool negated, CConcept* backPropConcept) {
3021 CConceptTriggerLinker* triggers = nullptr;
3022
3023 CConcept* backPropImpConcept = nullptr;
3024 CConcept* backPropTriggerConcept = nullptr;
3025 CConcept** backPropImpConceptPointer = nullptr;
3026 bool branchTiggerCreation = false;
3027 if (backPropConcept) {
3028 branchTiggerCreation = true;
3029 backPropImpConceptPointer = &backPropImpConcept;
3030 }
3031 TConceptNegationPair conNegPair(concept,negated);
3032 triggers = mConceptTriggerLinkerHash.value(conNegPair);
3033 if (triggers && backPropConcept) {
3034 CConcept* backPropActivCon = mBackPropActivationConHash.value(conNegPair);
3035 if (backPropActivCon) {
3036 addUnfoldingConceptForConcept(backPropConcept, backPropActivCon, false);
3037 }
3038 }
3039 if (!triggers) {
3040 if (backPropConcept) {
3041 backPropTriggerConcept = createTriggerConcept(branchTiggerCreation);
3042 addUnfoldingConceptForConcept(backPropConcept, backPropTriggerConcept, false);
3043 }
3044 cint64 opCode = concept->getOperatorCode();
3045 cint64 parm = concept->getParameter();
3046 cint64 opCount = concept->getOperandCount();
3047 CRole* role = concept->getRole();
3048 CSortedNegLinker<CConcept*>* opConLinker = concept->getOperandList();
3049
3050 if (!negated && (opCode == CCATOM || opCode == CCSUB || opCode == CCTOP || opCode == CCIMPLTRIG)) {
3051 CConceptTriggerLinker* newTrigger = createTriggerLinker();
3052 newTrigger->initConceptTriggerLinker(concept, 1);
3053 if (backPropConcept) {
3054 CConceptTriggerLinker* implTriggeredConcept = getImplicationTriggeredConceptForTriggers(newTrigger, backPropImpConceptPointer);
3055 addUnfoldingConceptForConcept(backPropTriggerConcept, backPropImpConcept, false);
3056 newTrigger = implTriggeredConcept;
3057 }
3058 triggers = newTrigger->append(triggers);
3059
3060
3061 } else if (negated && (opCode == CCOR) || !negated && (opCode == CCAND || opCode == CCEQ)) {
3062 // AND, collect triggers from operands
3063 CConceptTriggerLinker* andTriggers = nullptr;
3064 for (CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
3065 CConcept* opConcept = opConLinkerIt->getData();
3066 bool opNegated = opConLinkerIt->isNegated()^negated;
3067
3068 CConceptTriggerLinker* newTriggers = copyTriggerLinkers(getTriggersForConcept(opConcept,opNegated, backPropTriggerConcept));
3069 andTriggers = newTriggers->append(andTriggers);
3070 }
3071 if (backPropConcept) {
3072 CConceptTriggerLinker* implTriggeredConcept = getImplicationTriggeredConceptForTriggers(andTriggers, &backPropImpConcept);
3073 addUnfoldingConceptForConcept(backPropTriggerConcept, backPropImpConcept, false);
3074 andTriggers = implTriggeredConcept;
3075 }
3076 triggers = andTriggers->append(triggers);
3077
3078 } else if (opCode == CCAQCHOOCE) {
3079 CConceptTriggerLinker* andTriggers = nullptr;
3080 for (CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
3081 CConcept* opConcept = opConLinkerIt->getData();
3082 bool opNegated = opConLinkerIt->isNegated() ^ negated;
3083
3084 if (opNegated == negated) {
3085 CConceptTriggerLinker* newTriggers = copyTriggerLinkers(getTriggersForConcept(opConcept, opNegated, backPropTriggerConcept));
3086 andTriggers = newTriggers->append(andTriggers);
3087 }
3088 }
3089 if (backPropConcept) {
3090 CConceptTriggerLinker* implTriggeredConcept = getImplicationTriggeredConceptForTriggers(andTriggers, &backPropImpConcept);
3091 addUnfoldingConceptForConcept(backPropTriggerConcept, backPropImpConcept, false);
3092 andTriggers = implTriggeredConcept;
3093 }
3094 triggers = andTriggers->append(triggers);
3095
3096
3097 } else if (!negated && (opCode == CCOR) || negated && (opCode == CCAND || opCode == CCEQ)) {
3098 // or trigger
3099 CConceptTriggerLinker* orTriggers = nullptr;
3100 for (CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
3101 CConcept* opConcept = opConLinkerIt->getData();
3102 bool opNegated = opConLinkerIt->isNegated()^negated;
3103
3104 CConceptTriggerLinker* newTriggers = copyTriggerLinkers(getTriggersForConcept(opConcept,opNegated, backPropTriggerConcept));
3105 if (newTriggers->hasNext()) {
3106 CConceptTriggerLinker* implTriggeredConcept = getImplicationTriggeredConceptForTriggers(newTriggers, backPropImpConceptPointer);
3107 if (backPropImpConceptPointer) {
3108 addUnfoldingConceptForConcept(backPropTriggerConcept, backPropImpConcept, false);
3109 }
3110 orTriggers = implTriggeredConcept->append(orTriggers);
3111 } else {
3112 orTriggers = newTriggers->append(orTriggers);
3113 }
3114 }
3115 if (orTriggers) {
3116 if (orTriggers->hasNext()) {
3117 // more than one trigger
3118 cint64 triggerComplexity = 0;
3119 cint64 triggerCount = 0;
3120 CConcept* triggerConcept = createTriggerConcept(branchTiggerCreation);
3121 for (CConceptTriggerLinker* orTriggerIt = orTriggers; orTriggerIt; orTriggerIt = orTriggerIt->getNext()) {
3122 triggerComplexity += orTriggerIt->getTriggerComplexity();
3123 triggerCount++;
3124 addUnfoldingConceptForConcept(orTriggerIt->getTriggerConcept(),triggerConcept,false);
3125 }
3126 CConceptTriggerLinker* newTrigger = createTriggerLinker();
3127 newTrigger->initConceptTriggerLinker(triggerConcept,(triggerComplexity+1)/triggerCount);
3128 triggers = newTrigger->append(triggers);
3129 //releaseTriggerLinkers(orTriggers);
3130 } else {
3131 // only one trigger, add simply to other triggers
3132 triggers = orTriggers->append(triggers);
3133 }
3134 }
3135
3136
3137 } else if (!negated && (opCode == CCSOME || opCode == CCSELF || opCode == CCAQSOME) || negated && (opCode == CCALL) ||
3138 !negated && (opCode == CCATLEAST && parm == 1) || negated && (opCode == CCATMOST && parm == 0)) {
3139 CConcept* propagatedTriggerConcept = nullptr;
3140 cint64 triggerComplexity = 1;
3141 bool negateOperands = negated && (opCode == CCSOME || opCode == CCSELF || opCode == CCALL);
3142 CConceptTriggerLinker* allTriggers = nullptr;
3143 CConcept* roleBackPropTriggerConcept = nullptr;
3144 if (backPropConcept) {
3145 roleBackPropTriggerConcept = createTriggerConcept(branchTiggerCreation);
3146 CConcept* roleBackPropConcept = createTriggerPropagationConcept(roleBackPropTriggerConcept, role, branchTiggerCreation, false);
3147 addUnfoldingConceptForConcept(backPropTriggerConcept, roleBackPropConcept, false);
3148 }
3149 for (CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
3150 CConcept* opConcept = opConLinkerIt->getData();
3151 bool opNegated = opConLinkerIt->isNegated()^negateOperands;
3152 if (!(!opNegated && opConcept == mTopConcept || opNegated && opConcept == mBottomConcept)) {
3153 CConceptTriggerLinker* newTrigger = copyTriggerLinkers(getTriggersForConcept(opConcept,opNegated, roleBackPropTriggerConcept));
3154 allTriggers = newTrigger->append(allTriggers);
3155 }
3156 }
3157 if (allTriggers) {
3158 propagatedTriggerConcept = createTriggerConcept(branchTiggerCreation);
3159 CConcept* nextLevelTriggerConcept = createTriggerPropagationConcept(propagatedTriggerConcept,role, branchTiggerCreation);
3160 if (allTriggers->hasNext()) {
3161 // requires a generation of an implication concept
3162 CConceptTriggerLinker* implTriggeredConcept = getImplicationTriggeredConceptForTriggers(allTriggers, backPropImpConceptPointer);
3163 if (backPropImpConceptPointer) {
3164 addUnfoldingConceptForConcept(roleBackPropTriggerConcept, backPropImpConcept, false);
3165 }
3166 triggerComplexity += implTriggeredConcept->getTriggerComplexity();
3167 addUnfoldingConceptForConcept(implTriggeredConcept->getTriggerConcept(),nextLevelTriggerConcept,false);
3168 } else {
3169 triggerComplexity += allTriggers->getTriggerComplexity();
3170 addUnfoldingConceptForConcept(allTriggers->getTriggerConcept(),nextLevelTriggerConcept,false);
3171 releaseTriggerLinkers(allTriggers);
3172 }
3173 } else {
3174 if (backPropConcept) {
3175 propagatedTriggerConcept = createTriggerConcept(branchTiggerCreation);
3176 CConcept* nextLevelTriggerConcept = createTriggerPropagationConcept(propagatedTriggerConcept, role, branchTiggerCreation);
3177 addUnfoldingConceptForConcept(roleBackPropTriggerConcept, nextLevelTriggerConcept, false);
3178 }
3179 else {
3180 CRole* locatedRole = CConceptRoleIndividualLocator::getLocatedRole(role, mOnto);
3181 propagatedTriggerConcept = getRoleDomainTriggerConcept(locatedRole);
3182 }
3183 }
3184 CConceptTriggerLinker* newTrigger = createTriggerLinker();
3185 newTrigger->initConceptTriggerLinker(propagatedTriggerConcept,triggerComplexity);
3186 triggers = newTrigger->append(triggers);
3187
3188
3189 } else if (!negated && (opCode == CCVALUE)) {
3190 CConcept* propagatedTriggerConcept = createTriggerConcept(branchTiggerCreation);
3191 CConcept* nextLevelTriggerConcept = createTriggerPropagationConcept(propagatedTriggerConcept,role, branchTiggerCreation);
3192
3193 cint64 triggerComplexity = 2;
3194
3195 CIndividual* individual = concept->getNominalIndividual();
3196
3197 if (!backPropConcept) {
3198 CIndividual* locatedIndividual = CConceptRoleIndividualLocator::getLocatedIndividual(individual, mOnto);
3199 CConceptAssertionLinker* assLinker = CObjectAllocator< CConceptAssertionLinker >::allocateAndConstruct(mMemMan);
3200 assLinker->initNegLinker(nextLevelTriggerConcept, false);
3201 locatedIndividual->addAssertionConceptLinker(assLinker);
3202
3203 if (!mIndividualTriggerConceptHash) {
3204 mIndividualTriggerConceptHash = mTBox->getIndividualTriggerConceptHash(true);
3205 }
3206 mIndividualTriggerConceptHash->insertMulti(individual->getIndividualID(), nextLevelTriggerConcept);
3207 } else {
3208 CConcept* roleBackPropTriggerConcept = createTriggerConcept(branchTiggerCreation);
3209 CConcept* roleBackPropConcept = createTriggerPropagationConcept(roleBackPropTriggerConcept, role, branchTiggerCreation, false);
3210 addUnfoldingConceptForConcept(backPropTriggerConcept, roleBackPropConcept, false);
3211
3212 CConcept* nomImpConcept = createNominalImplication(nextLevelTriggerConcept, individual);
3213 addUnfoldingConceptForConcept(roleBackPropTriggerConcept, nomImpConcept, false);
3214
3215 }
3216
3217
3218 CConceptTriggerLinker* newTrigger = createTriggerLinker();
3219 newTrigger->initConceptTriggerLinker(propagatedTriggerConcept,triggerComplexity);
3220 triggers = newTrigger->append(triggers);
3221
3222
3223 } else if (!negated && (opCode == CCNOMVAR)) {
3224 cint64 triggerComplexity = 1;
3225 CConcept* nominalTriggerConcept = mTBox->getIndividualTriggerConcept();
3226 CConceptTriggerLinker* newTrigger = createTriggerLinker();
3227 newTrigger->initConceptTriggerLinker(nominalTriggerConcept,triggerComplexity);
3228 triggers = newTrigger->append(triggers);
3229
3230
3231 } else if (!negated && (opCode == CCNOMINAL)) {
3232 CConcept* nominalTriggerConcept = createTriggerConcept(branchTiggerCreation);
3233 cint64 triggerComplexity = 1;
3234
3235 CIndividual* individual = concept->getNominalIndividual();
3236 if (!backPropConcept) {
3237 CIndividual* locatedIndividual = CConceptRoleIndividualLocator::getLocatedIndividual(individual, mOnto);
3238 CConceptAssertionLinker* assLinker = CObjectAllocator< CConceptAssertionLinker >::allocateAndConstruct(mMemMan);
3239 assLinker->initNegLinker(nominalTriggerConcept,false);
3240 locatedIndividual->addAssertionConceptLinker(assLinker);
3241
3242 if (!mIndividualTriggerConceptHash) {
3243 mIndividualTriggerConceptHash = mTBox->getIndividualTriggerConceptHash(true);
3244 }
3245 mIndividualTriggerConceptHash->insertMulti(individual->getIndividualID(),nominalTriggerConcept);
3246 } else {
3247 CConcept* nomImpConcept = createNominalImplication(nominalTriggerConcept, individual);
3248 addUnfoldingConceptForConcept(backPropTriggerConcept, nomImpConcept, false);
3249 }
3250
3251 CConceptTriggerLinker* newTrigger = createTriggerLinker();
3252 newTrigger->initConceptTriggerLinker(nominalTriggerConcept,triggerComplexity);
3253 triggers = newTrigger->append(triggers);
3254 }
3255
3256
3257 mConceptTriggerLinkerHash.insert(conNegPair,triggers);
3258 if (backPropTriggerConcept) {
3259 mBackPropActivationConHash.insert(conNegPair, backPropTriggerConcept);
3260 }
3261 }
3262 return triggers;
3263 }
3264
3265
3266 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::getImplicationImpliedConcept(CConcept* implicationConcept) {
3267 CConcept* impliedConcept = nullptr;
3268 cint64 param = implicationConcept->getParameter();
3269 if (param >= 1) {
3270 CSortedNegLinker<CConcept*>* opConLinkerIt = implicationConcept->getOperandList();
3271 while (opConLinkerIt && param-- >= 0 && !impliedConcept) {
3272 if (!opConLinkerIt->isNegated()) {
3273 CConcept* concept = opConLinkerIt->getData();
3274 if (concept->getOperatorCode() == CCIMPLTRIG) {
3275 impliedConcept = concept;
3276 }
3277 }
3278 opConLinkerIt = opConLinkerIt->getNext();
3279 }
3280 }
3281 return impliedConcept;
3282 }
3283
3284 bool CTriggeredImplicationBinaryAbsorberPreProcess::findAndReplaceImplicationFromTriggers(CConceptTriggerLinker* trigger, CConceptTriggerLinker*& otherTriggers) {
3285 if (!mConfImplicationsForTriggerReusue) {
3286 return false;
3287 }
3288 if (otherTriggers) {
3289 CConcept* concept1 = trigger->getTriggerConcept();
3290 CConceptTriggerLinker* triggerIt = otherTriggers;
3291 CConceptTriggerLinker* lastTriggerIt = nullptr;
3292 while (triggerIt) {
3293 CConcept* concept2 = triggerIt->getTriggerConcept();
3294 CConcept* minConcept1 = qMin(concept1,concept2);
3295 CConcept* maxConcept1 = qMax(concept1,concept2);
3296 TConceptPair conceptPair(minConcept1,maxConcept1);
3297 CConceptTriggerLinker* impliedConceptTrigger = mConceptImplicationImpliedHash.value(conceptPair);
3298 if (impliedConceptTrigger) {
3299 CConceptTriggerLinker* relTrigger = triggerIt;
3300 triggerIt = triggerIt->getNext();
3301 relTrigger->clearNext();
3302 *trigger = *impliedConceptTrigger;
3303 if (lastTriggerIt) {
3304 lastTriggerIt->setNext(triggerIt);
3305 } else {
3306 otherTriggers = triggerIt;
3307 }
3308 releaseTriggerLinkers(relTrigger);
3309 return true;
3310 } else {
3311 lastTriggerIt = triggerIt;
3312 triggerIt = triggerIt->getNext();
3313 }
3314 }
3315 }
3316 return false;
3317 }
3318
3319
3320
3321 CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getUpdatedTriggerComplexities(CConceptTriggerLinker* triggers) {
3322 if (mConfPunishOftenSameTriggerUse) {
3323 for (CConceptTriggerLinker* triggerIt = triggers; triggerIt; triggerIt = triggerIt->getNext()) {
3324 cint64 triggerOpCount = triggerIt->getTriggerConcept()->getOperandCount();
3325 if (triggerOpCount > mConfOftenTriggerUseCountPunishment) {
3326 cint64 triggerComplexityPunishment = triggerOpCount / mConfOftenTriggerUseCountPunishment;
3327 triggerIt->setTriggerComplexity(triggerIt->getTriggerComplexity()-triggerComplexityPunishment);
3328 }
3329 }
3330 }
3331 return triggers;
3332 }
3333
3334
3335
3336 CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getImplicationTriggeredConceptForTriggers(CConceptTriggerLinker* triggers, CConcept** firstImplicationConcept) {
3337 CConceptTriggerLinker* implicationTriggeredConcept = nullptr;
3338 CConceptTriggerLinker* sortedTriggers = nullptr;
3339 CConceptTriggerLinker* triggerIt = getUpdatedTriggerComplexities(triggers);
3340 while (triggerIt) {
3341 CConceptTriggerLinker* trigger = triggerIt;
3342 triggerIt = triggerIt->getNext();
3343 trigger->clearNext();
3344
3345 if ((triggerIt || sortedTriggers) && trigger->getTriggerConcept() == mTopConcept) {
3346 // ignore trigger
3347 } else {
3348 bool replaced = true;
3349 bool checkSorted = false;
3350 while (replaced) {
3351 replaced = false;
3352 if (findAndReplaceImplicationFromTriggers(trigger,triggerIt)) {
3353 ++mStatReusedImplications;
3354 replaced = true;
3355 checkSorted = true;
3356 } else {
3357 if (checkSorted) {
3358 if (findAndReplaceImplicationFromTriggers(trigger,sortedTriggers)) {
3359 ++mStatReusedImplications;
3360 replaced = true;
3361 }
3362 }
3363 }
3364 }
3365
3366 if (sortedTriggers) {
3367 sortedTriggers = sortedTriggers->insertNextSorted(trigger);
3368 } else {
3369 sortedTriggers = trigger;
3370 }
3371 }
3372
3373 }
3374 if (firstImplicationConcept) {
3375 *firstImplicationConcept = nullptr;
3376 if (sortedTriggers) {
3377 CConceptTriggerLinker* trigger1 = sortedTriggers;
3378
3379 CConcept* newImpliedTriggerConcept = createTriggerConcept(firstImplicationConcept != nullptr);
3380 CConcept* newImplicationConcept = createImplicationConcept(newImpliedTriggerConcept,false);
3381 addImplicationTrigger(newImplicationConcept,trigger1->getTriggerConcept(),true);
3382 trigger1->initConceptTriggerLinker(newImpliedTriggerConcept,trigger1->getTriggerComplexity());
3383 *firstImplicationConcept = newImplicationConcept;
3384
3385 implicationTriggeredConcept = trigger1;
3386
3387 }
3388 }
3389
3390 if (sortedTriggers) {
3391 if (!sortedTriggers->hasNext()) {
3392 implicationTriggeredConcept = sortedTriggers;
3393 } else {
3394 CConceptTriggerLinker* trigger1 = sortedTriggers;
3395 sortedTriggers = sortedTriggers->getNext();
3396 triggerIt = sortedTriggers;
3397 trigger1->clearNext();
3398 while (triggerIt) {
3399 CConceptTriggerLinker* trigger2 = triggerIt;
3400 triggerIt = triggerIt->getNext();
3401 trigger2->clearNext();
3402
3403 CConcept* newImpliedTriggerConcept = createTriggerConcept(firstImplicationConcept != nullptr);
3404 CConcept* newImplicationConcept = createImplicationConcept(newImpliedTriggerConcept,false);
3405
3406 CConcept* concept1 = trigger1->getTriggerConcept();
3407 CConcept* concept2 = trigger2->getTriggerConcept();
3408
3409 addImplicationTrigger(newImplicationConcept,concept2,true);
3410 addUnfoldingConceptForConcept(concept1,newImplicationConcept,false);
3411 cint64 newTriggerComplexity = trigger1->getTriggerComplexity()+trigger2->getTriggerComplexity();
3412
3413 CConcept* minConcept1 = qMin(concept1,concept2);
3414 CConcept* maxConcept1 = qMax(concept1,concept2);
3415 TConceptPair conceptPair(minConcept1,maxConcept1);
3416 trigger2->initConceptTriggerLinker(newImpliedTriggerConcept,newTriggerComplexity);
3417 mConceptImplicationImpliedHash.insert(conceptPair,trigger2);
3418
3419 trigger1->initConceptTriggerLinker(newImpliedTriggerConcept,newTriggerComplexity);
3420 }
3421 implicationTriggeredConcept = trigger1;
3422 }
3423 if (!mTriggerImplHash->contains(implicationTriggeredConcept->getTriggerConcept())) {
3424 mTriggerImplHash->insertMulti(implicationTriggeredConcept->getTriggerConcept(),nullptr);
3425 }
3426 }
3427 return implicationTriggeredConcept;
3428 }
3429
3430
3431 void CTriggeredImplicationBinaryAbsorberPreProcess::addUnfoldingConceptForConcept(CConcept* concept, CConcept* addingUnfoldingConcept, bool addingNegation) {
3432 cint64 opCode = concept->getOperatorCode();
3433 if (opCode == CCTOP) {
3434 CSortedNegLinker<CConcept*>* newOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
3435 newOpCon->init(addingUnfoldingConcept,addingNegation);
3436 mLaterTopConceptTriggerAddList.append(newOpCon);
3437 } else {
3438 CSortedNegLinker<CConcept*>* newOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
3439 newOpCon->init(addingUnfoldingConcept,addingNegation,concept->getOperandList());
3440 concept->setOperandList(newOpCon);
3441 concept->incOperandCount();
3442 if (opCode == CCATOM) {
3443 concept->setOperatorCode(CCSUB);
3444 }
3445 }
3446 }
3447
3448
3449 void CTriggeredImplicationBinaryAbsorberPreProcess::addUnfoldingConceptForImplicationConcept(CConcept* implicationConcept, CConcept* addingUnfoldingConcept, bool addingNegation) {
3450 CSortedNegLinker<CConcept*>* newOpCon = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
3451 newOpCon->init(addingUnfoldingConcept,addingNegation,implicationConcept->getOperandList());
3452 implicationConcept->setOperandList(newOpCon);
3453 implicationConcept->incOperandCount();
3454 implicationConcept->setParameter(implicationConcept->getParameter()+1);
3455 }
3456
3457
3458
3459 CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::createTriggerLinker() {
3460 CConceptTriggerLinker* newTrigger = mTmpTriggerLinker;
3461 if (newTrigger) {
3462 mTmpTriggerLinker = mTmpTriggerLinker->getNext();
3463 } else {
3464 newTrigger = new CConceptTriggerLinker();
3465 mTriggerContainer.append(newTrigger);
3466 }
3467 newTrigger->clearNext();
3468 return newTrigger;
3469 }
3470
3471 void CTriggeredImplicationBinaryAbsorberPreProcess::releaseTriggerLinkers(CConceptTriggerLinker* triggers) {
3472 if (triggers) {
3473 mTmpTriggerLinker = triggers->append(mTmpTriggerLinker);
3474 }
3475 }
3476
3477
3478 CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::copyTriggerLinkers(CConceptTriggerLinker* triggers) {
3479 CConceptTriggerLinker* newTriggers = nullptr;
3480 for (CConceptTriggerLinker* triggerIt = triggers; triggerIt; triggerIt = triggerIt->getNext()) {
3481 CConceptTriggerLinker* newTrigger = createTriggerLinker()->initConceptTriggerLinker(triggerIt->getTriggerConcept(),triggerIt->getTriggerComplexity());
3482 newTriggers = newTrigger->append(newTriggers);
3483 }
3484 return newTriggers;
3485 }
3486
3487
3488 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createMarkerConcept() {
3489 CConcept* markerConcept = createNewConcept();
3490 markerConcept->setOperatorCode(CCMARKER);
3491 return markerConcept;
3492 }
3493
3494
3495 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createTriggerConcept(bool branchTrigger) {
3496 CConcept* triggerConcept = createNewConcept();
3497 if (branchTrigger) {
3498 triggerConcept->setOperatorCode(CCBRANCHTRIG);
3499 } else {
3500 triggerConcept->setOperatorCode(CCIMPLTRIG);
3501 }
3502 return triggerConcept;
3503 }
3504
3505
3506
3507 bool CTriggeredImplicationBinaryAbsorberPreProcess::isDisjunctionConceptSimpleTriggeredImplicationAbsorbable(CConcept* orConcept, bool negated) {
3508 cint64 notAbsorbableCount = 0;
3509 cint64 absorbableCount = 0;
3510 CSortedNegLinker<CConcept*>* opConLinkerIt = orConcept->getOperandList();
3511 while (opConLinkerIt) {
3512 CConcept* opConcept = opConLinkerIt->getData();
3513 bool opNegated = opConLinkerIt->isNegated();
3514 if (isConceptSimpleImplicationTriggerable(opConcept,!opNegated^negated)) {
3515 absorbableCount++;
3516 } else {
3517 notAbsorbableCount++;
3518 }
3519 opConLinkerIt = opConLinkerIt->getNext();
3520 }
3521 if (notAbsorbableCount <= 1) {
3522 return true;
3523 }
3524 return false;
3525 }
3526
3527
3528
3529
3530 bool CTriggeredImplicationBinaryAbsorberPreProcess::isDisjunctionConceptTriggeredImplicationAbsorbable(CConcept* orConcept, bool negated) {
3531 cint64 notAbsorbableCount = 0;
3532 cint64 absorbableCount = 0;
3533 QHash<CConcept*,TOccuredAbsorbablePair> conceptEqConAbsorbed;
3534 CSortedNegLinker<CConcept*>* opConLinkerIt = orConcept->getOperandList();
3535 while (opConLinkerIt) {
3536 CConcept* opConcept = opConLinkerIt->getData();
3537 bool opNegated = opConLinkerIt->isNegated();
3538 if (isConceptImplicationTriggerable(opConcept,!opNegated^negated,&conceptEqConAbsorbed)) {
3539 absorbableCount++;
3540 } else {
3541 notAbsorbableCount++;
3542 }
3543 opConLinkerIt = opConLinkerIt->getNext();
3544 }
3545 if (notAbsorbableCount <= 1) {
3546 return true;
3547 }
3548 return false;
3549 }
3550
3551 bool CTriggeredImplicationBinaryAbsorberPreProcess::isDisjunctionConceptPartialTriggeredImplicationAbsorbable(CConcept* orConcept, bool negated) {
3552 CSortedNegLinker<CConcept*>* opConLinkerIt = orConcept->getOperandList();
3553 QSet<CConcept*> conceptEqConAbsorbed;
3554 bool partialTriggerable = false;
3555 while (opConLinkerIt) {
3556 CConcept* opConcept = opConLinkerIt->getData();
3557 bool opNegated = opConLinkerIt->isNegated();
3558 if (isConceptPartialImplicationTriggerable(opConcept,!opNegated^negated,&conceptEqConAbsorbed)) {
3559 partialTriggerable = true;
3560 }
3561 opConLinkerIt = opConLinkerIt->getNext();
3562 }
3563 return partialTriggerable;
3564 }
3565
3566
3567
3568
3569
3570
3571
3572
3573 bool CTriggeredImplicationBinaryAbsorberPreProcess::isCardinalityConceptQualificationTriggerAbsorbable(CConcept* cardConcept, bool negated) {
3574 bool triggerable = false;
3575 QHash<CConcept*,TOccuredAbsorbablePair> conceptEqConAbsorbed;
3576 CSortedNegLinker<CConcept*>* opConLinkerIt = cardConcept->getOperandList();
3577 while (opConLinkerIt) {
3578 CConcept* opConcept = opConLinkerIt->getData();
3579 bool opNegated = opConLinkerIt->isNegated();
3580 if (isConceptImplicationTriggerable(opConcept,opNegated,&conceptEqConAbsorbed)) {
3581 triggerable = true;
3582 }
3583 opConLinkerIt = opConLinkerIt->getNext();
3584 }
3585 return triggerable;
3586 }
3587
3588 bool CTriggeredImplicationBinaryAbsorberPreProcess::isCardinalityConceptPartialQualificationTriggerAbsorbable(CConcept* cardConcept, bool negated) {
3589 CSortedNegLinker<CConcept*>* opConLinkerIt = cardConcept->getOperandList();
3590 QSet<CConcept*> conceptEqConAbsorbed;
3591 bool partialTriggerable = false;
3592 while (opConLinkerIt) {
3593 CConcept* opConcept = opConLinkerIt->getData();
3594 bool opNegated = opConLinkerIt->isNegated();
3595 if (isConceptPartialImplicationTriggerable(opConcept,opNegated,&conceptEqConAbsorbed)) {
3596 partialTriggerable = true;
3597 }
3598 opConLinkerIt = opConLinkerIt->getNext();
3599 }
3600 return partialTriggerable;
3601 }
3602
3603
3604
3605
3606
3607
3608
3609 bool CTriggeredImplicationBinaryAbsorberPreProcess::isEquivalenceConceptTriggeredImplicationAbsorbable(CConcept* orConcept, bool negated, cint64* notAbsorbableOperandsCount) {
3610 cint64 notAbsorbableCount = 0;
3611 cint64 opCode = orConcept->getOperatorCode();
3612 QHash<CConcept*,TOccuredAbsorbablePair> conceptEqConAbsorbed;
3613 if (!negated && opCode == CCEQ) {
3614 CSortedNegLinker<CConcept*>* opConLinkerIt = orConcept->getOperandList();
3615 while (opConLinkerIt) {
3616 CConcept* opConcept = opConLinkerIt->getData();
3617 bool opNegated = opConLinkerIt->isNegated();
3618 if (!isConceptImplicationTriggerable(opConcept,opNegated,&conceptEqConAbsorbed)) {
3619 return false;
3620 }
3621 opConLinkerIt = opConLinkerIt->getNext();
3622 }
3623 }
3624 return true;
3625 }
3626
3627
3628 bool CTriggeredImplicationBinaryAbsorberPreProcess::isEquivalenceConceptCandidateExtractable(CConcept* orConcept, bool negated) {
3629 cint64 notAbsorbableCount = 0;
3630 cint64 opCode = orConcept->getOperatorCode();
3631 QSet<CConcept*> conceptEqConAbsorbed;
3632 bool partialTriggerable = false;
3633 if (!negated && opCode == CCEQ) {
3634 CSortedNegLinker<CConcept*>* opConLinkerIt = orConcept->getOperandList();
3635 while (opConLinkerIt) {
3636 CConcept* opConcept = opConLinkerIt->getData();
3637 bool opNegated = opConLinkerIt->isNegated();
3638 if (isConceptPartialImplicationTriggerable(opConcept,opNegated,&conceptEqConAbsorbed)) {
3639 partialTriggerable = true;
3640 }
3641 opConLinkerIt = opConLinkerIt->getNext();
3642 }
3643 }
3644 return partialTriggerable;
3645 }
3646
3647
3648 bool CTriggeredImplicationBinaryAbsorberPreProcess::isGCIConceptTriggeredImplicationAbsorbable(CConcept* orConcept, bool negated, cint64* notAbsorbableOperandsCount) {
3649 bool absorbable = false;
3650 cint64 notAbsorbableCount = 0;
3651 cint64 opCode = orConcept->getOperatorCode();
3652 QHash<CConcept*,TOccuredAbsorbablePair> conceptEqConAbsorbed;
3653 if (!negated && opCode == CCOR || negated && opCode == CCAND) {
3654 CSortedNegLinker<CConcept*>* opConLinkerIt = orConcept->getOperandList();
3655 while (opConLinkerIt) {
3656 CConcept* opConcept = opConLinkerIt->getData();
3657 bool opNegated = opConLinkerIt->isNegated();
3658 if (isConceptImplicationTriggerable(opConcept,!opNegated,&conceptEqConAbsorbed)) {
3659 absorbable = true;
3660 } else {
3661 notAbsorbableCount++;
3662 }
3663 opConLinkerIt = opConLinkerIt->getNext();
3664 }
3665 }
3666 if (notAbsorbableOperandsCount) {
3667 *notAbsorbableOperandsCount = notAbsorbableCount;
3668 }
3669 return absorbable;
3670 }
3671
3672
3673 bool CTriggeredImplicationBinaryAbsorberPreProcess::isConceptSimpleImplicationTriggerable(CConcept* concept, bool negated) {
3674 cint64 opCode = concept->getOperatorCode();
3675 cint64 parm = concept->getParameter();
3676 cint64 opCount = concept->getOperandCount();
3677 CSortedNegLinker<CConcept*>* opConLinker = concept->getOperandList();
3678 if (!negated && (opCode == CCSUB || opCode == CCATOM || opCode == CCIMPLTRIG)) {
3679 return true;
3680 } else if (!negated && (opCode == CCAND || opCode == CCEQ) || negated && opCode == CCOR) {
3681 if (opCount >= 1) {
3682 bool allOpsTriggerable = true;
3683 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
3684 while (opConLinkerIt && allOpsTriggerable) {
3685 CConcept* opConcept = opConLinkerIt->getData();
3686 bool opNegated = opConLinkerIt->isNegated()^negated;
3687 allOpsTriggerable &= isConceptSimpleImplicationTriggerable(opConcept,opNegated);
3688 opConLinkerIt = opConLinkerIt->getNext();
3689 }
3690 return allOpsTriggerable;
3691 }
3692 } else {
3693 if (mConceptTriggerLinkerHash.contains(TConceptNegationPair(concept,negated))) {
3694 return true;
3695 }
3696 }
3697 return false;
3698 }
3699
3700 void CTriggeredImplicationBinaryAbsorberPreProcess::mergeDependingCacheList(QList<TConceptNegationPair>** dependingCacheList, QList<TConceptNegationPair>** subDependingCacheList) {
3701 if (*subDependingCacheList) {
3702 if (!*dependingCacheList) {
3703 *dependingCacheList = *subDependingCacheList;
3704 } else {
3705 (*dependingCacheList)->append(**subDependingCacheList);
3706 delete *subDependingCacheList;
3707 }
3708 *subDependingCacheList = nullptr;
3709 }
3710 }
3711
3712
3713 bool CTriggeredImplicationBinaryAbsorberPreProcess::isConceptImplicationTriggerable(CConcept* concept, bool negated, QHash<CConcept*,TOccuredAbsorbablePair>* conceptEqConAbsorbed) {
3714 cint64 openMultipleOccurCount = 0;
3715 QList<TConceptNegationPair>* dependingCacheList = nullptr;
3716 return isConceptImplicationTriggerable(concept,negated,conceptEqConAbsorbed,&openMultipleOccurCount,&dependingCacheList);
3717 }
3718
3719
3720 bool CTriggeredImplicationBinaryAbsorberPreProcess::isConceptImplicationTriggerable(CConcept* concept, bool negated, QHash<CConcept*,TOccuredAbsorbablePair>* conceptEqConAbsorbed, cint64* openMultipleOccurCount, QList<TConceptNegationPair>** dependingCacheList) {
3721 TConceptNegationPair conNegPair(concept,negated);
3722 if (mConceptTotalAbsorbableHash.contains(conNegPair)) {
3723 return mConceptTotalAbsorbableHash.value(conNegPair);
3724 }
3725 cint64 opCode = concept->getOperatorCode();
3726 cint64 parm = concept->getParameter();
3727 cint64 opCount = concept->getOperandCount();
3728 CSortedNegLinker<CConcept*>* opConLinker = concept->getOperandList();
3729
3730 bool absorbable = false;
3731 QList<TConceptNegationPair>* subDependingCacheList = nullptr;
3732
3733 if (!negated && (opCode == CCSUB || opCode == CCATOM || opCode == CCTOP || opCode == CCIMPLTRIG)) {
3734 absorbable = true;
3735 } else if (!negated && (opCode == CCNOMINAL)) {
3736 absorbable = true;
3737 } else if (!negated && (opCode == CCNOMVAR)) {
3738 absorbable = true;
3739 } else if (!negated && (opCode == CCVALUE)) {
3740 absorbable = true;
3741 }
3742 else if (opCode == CCAQCHOOCE) {
3743 absorbable = true;
3744 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
3745 while (opConLinkerIt) {
3746 CConcept* opConcept = opConLinkerIt->getData();
3747 bool opNegated = opConLinkerIt->isNegated();
3748 if (opNegated == negated) {
3749 absorbable &= isConceptImplicationTriggerable(opConcept, opNegated, conceptEqConAbsorbed, openMultipleOccurCount, &subDependingCacheList);
3750 mergeDependingCacheList(dependingCacheList, &subDependingCacheList);
3751 }
3752 opConLinkerIt = opConLinkerIt->getNext();
3753 }
3754
3755 } else if (!negated && (opCode == CCSOME || opCode == CCAQSOME) || negated && (opCode == CCALL)) {
3756 if (!opConLinker) {
3757 absorbable = true;
3758 } else {
3759 bool allOpsTriggerable = true;
3760 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
3761 while (opConLinkerIt && allOpsTriggerable) {
3762 CConcept* opConcept = opConLinkerIt->getData();
3763 bool opNegated = opConLinkerIt->isNegated()^negated;
3764 allOpsTriggerable &= isConceptImplicationTriggerable(opConcept,opNegated,conceptEqConAbsorbed,openMultipleOccurCount,&subDependingCacheList);
3765 mergeDependingCacheList(dependingCacheList,&subDependingCacheList);
3766 opConLinkerIt = opConLinkerIt->getNext();
3767 }
3768 absorbable = allOpsTriggerable;
3769 }
3770 } else if (!negated && (opCode == CCATLEAST && parm == 1) || negated && (opCode == CCATMOST && parm == 0)) {
3771 if (!opConLinker) {
3772 absorbable = true;
3773 } else {
3774 bool allOpsTriggerable = true;
3775 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
3776 while (opConLinkerIt && allOpsTriggerable) {
3777 CConcept* opConcept = opConLinkerIt->getData();
3778 bool opNegated = opConLinkerIt->isNegated();
3779 allOpsTriggerable &= isConceptImplicationTriggerable(opConcept,opNegated,conceptEqConAbsorbed,openMultipleOccurCount,&subDependingCacheList);
3780 mergeDependingCacheList(dependingCacheList,&subDependingCacheList);
3781 opConLinkerIt = opConLinkerIt->getNext();
3782 }
3783 absorbable = allOpsTriggerable;
3784 }
3785 } else if (opCode == CCAND || opCode == CCOR) {
3786 bool allOpsTriggerable = true;
3787 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
3788 while (opConLinkerIt && allOpsTriggerable) {
3789 CConcept* opConcept = opConLinkerIt->getData();
3790 bool opNegated = opConLinkerIt->isNegated()^negated;
3791 allOpsTriggerable &= isConceptImplicationTriggerable(opConcept,opNegated,conceptEqConAbsorbed,openMultipleOccurCount,&subDependingCacheList);
3792 mergeDependingCacheList(dependingCacheList,&subDependingCacheList);
3793 opConLinkerIt = opConLinkerIt->getNext();
3794 }
3795 absorbable = allOpsTriggerable;
3796 } else if (opCode == CCEQ) {
3797 if (negated) {
3798 absorbable = false;
3799 } else {
3800 TOccuredAbsorbablePair& occAbsPair = (*conceptEqConAbsorbed)[concept];
3801 if (occAbsPair.first) {
3802 if (!occAbsPair.second) {
3803 occAbsPair.second = true;
3804 ++(*openMultipleOccurCount);
3805 }
3806 if (!*dependingCacheList) {
3807 *dependingCacheList = new QList<TConceptNegationPair>();
3808 }
3809 absorbable = true;
3810 } else {
3811
3812 occAbsPair.first = true;
3813 bool allOpsTriggerable = true;
3814 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
3815 while (opConLinkerIt && allOpsTriggerable) {
3816 CConcept* opConcept = opConLinkerIt->getData();
3817 bool opNegated = opConLinkerIt->isNegated()^negated;
3818 allOpsTriggerable &= isConceptImplicationTriggerable(opConcept,opNegated,conceptEqConAbsorbed,openMultipleOccurCount,&subDependingCacheList);
3819 mergeDependingCacheList(dependingCacheList,&subDependingCacheList);
3820 opConLinkerIt = opConLinkerIt->getNext();
3821 }
3822
3823 if (*dependingCacheList) {
3824 if (!allOpsTriggerable) {
3825 for (QList<TConceptNegationPair>::const_iterator it = (*dependingCacheList)->constBegin(), itEnd = (*dependingCacheList)->constEnd(); it != itEnd; ++it) {
3826 TConceptNegationPair upConNegPair(*it);
3827 mConceptTotalAbsorbableHash.insert(upConNegPair,false);
3828 }
3829 delete *dependingCacheList;
3830 *dependingCacheList = nullptr;
3831 }
3832 }
3833
3834 if (occAbsPair.second) {
3835 if (--(*openMultipleOccurCount) <= 0) {
3836 if (*dependingCacheList && allOpsTriggerable) {
3837 for (QList<TConceptNegationPair>::const_iterator it = (*dependingCacheList)->constBegin(), itEnd = (*dependingCacheList)->constEnd(); it != itEnd; ++it) {
3838 TConceptNegationPair upConNegPair(*it);
3839 mConceptTotalAbsorbableHash.insert(upConNegPair,true);
3840 }
3841 delete *dependingCacheList;
3842 *dependingCacheList = nullptr;
3843 }
3844 }
3845 }
3846
3847 absorbable = allOpsTriggerable;
3848 }
3849 }
3850 } else {
3851 absorbable = false;
3852 }
3853 if (absorbable) {
3854 if (*dependingCacheList) {
3855 (*dependingCacheList)->append(conNegPair);
3856 } else {
3857 mConceptTotalAbsorbableHash.insert(conNegPair,absorbable);
3858 }
3859 } else {
3860 mConceptTotalAbsorbableHash.insert(conNegPair,absorbable);
3861 }
3862 return absorbable;
3863 }
3864
3865
3866
3867
3868
3869
3870
3871
3872 bool CTriggeredImplicationBinaryAbsorberPreProcess::absorbGCIConceptsToTriggeredImplications(CConcept* orConcept, bool negated) {
3873 cint64 opCode = orConcept->getOperatorCode();
3874 if (!negated && opCode == CCOR || negated && opCode == CCAND) {
3875 QList<TConceptNegationPair> candList;
3876 if (addAbsorbableDisjunctCandidates(orConcept,negated,candList)) {
3877 if (candList.count() >= 1) {
3878 QList<TConceptNegationPair> absorbList(splitAbsorbableDisjuncts(candList));
3879 if (!absorbList.isEmpty()) {
3880 createGCIAbsorbedTriggeredImplication(orConcept,negated,absorbList,candList);
3881 return true;
3882 }
3883 }
3884 }
3885 }
3886 return false;
3887 }
3888
3889
3890
3891
3892 bool CTriggeredImplicationBinaryAbsorberPreProcess::isConceptPartialImplicationTriggerable(CConcept* concept, bool negated, QSet<CConcept*>* conceptEqConAbsorbed) {
3893 TConceptNegationPair conNegPair(concept,negated);
3894 if (mConceptPartialAbsorbableHash.contains(conNegPair)) {
3895 return mConceptPartialAbsorbableHash.value(conNegPair);
3896 }
3897
3898 cint64 opCode = concept->getOperatorCode();
3899 cint64 parm = concept->getParameter();
3900 cint64 opCount = concept->getOperandCount();
3901 CSortedNegLinker<CConcept*>* opConLinker = concept->getOperandList();
3902
3903 bool absorbable = false;
3904
3905 if (!negated && (opCode == CCSUB || opCode == CCATOM || opCode == CCTOP || opCode == CCIMPLTRIG)) {
3906 absorbable = true;
3907 } else if (!negated && (opCode == CCNOMINAL)) {
3908 absorbable = true;
3909 } else if (!negated && (opCode == CCNOMVAR)) {
3910 absorbable = true;
3911 } else if (!negated && (opCode == CCVALUE)) {
3912 absorbable = true;
3913 } else if (!negated && (opCode == CCSELF)) {
3914 absorbable = true;
3915 } else if (opCode == CCAQCHOOCE) {
3916 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
3917 while (opConLinkerIt) {
3918 CConcept* opConcept = opConLinkerIt->getData();
3919 bool opNegated = opConLinkerIt->isNegated();
3920 if (opNegated == negated) {
3921 absorbable |= isConceptPartialImplicationTriggerable(opConcept, opNegated, conceptEqConAbsorbed);
3922 }
3923 opConLinkerIt = opConLinkerIt->getNext();
3924 }
3925 } else if (!negated && (opCode == CCSOME || opCode == CCAQSOME) || negated && (opCode == CCALL)) {
3926 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
3927 while (opConLinkerIt) {
3928 CConcept* opConcept = opConLinkerIt->getData();
3929 bool opNegated = opConLinkerIt->isNegated()^negated;
3930 isConceptPartialImplicationTriggerable(opConcept,opNegated,conceptEqConAbsorbed);
3931 opConLinkerIt = opConLinkerIt->getNext();
3932 }
3933 absorbable = true;
3934 } else if (!negated && (opCode == CCATLEAST && parm >= 1) || negated && (opCode == CCATMOST && parm >= 0)) {
3935 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
3936 while (opConLinkerIt) {
3937 CConcept* opConcept = opConLinkerIt->getData();
3938 bool opNegated = opConLinkerIt->isNegated()^negated;
3939 isConceptPartialImplicationTriggerable(opConcept,opNegated,conceptEqConAbsorbed);
3940 opConLinkerIt = opConLinkerIt->getNext();
3941 }
3942 absorbable = true;
3943 } else if (!negated && (opCode == CCAND) || negated && opCode == CCOR) {
3944 // AND, at least one operand has to be triggerable
3945 if (opCount >= 1) {
3946 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
3947 while (opConLinkerIt) {
3948 CConcept* opConcept = opConLinkerIt->getData();
3949 bool opNegated = opConLinkerIt->isNegated()^negated;
3950 if (isConceptPartialImplicationTriggerable(opConcept,opNegated,conceptEqConAbsorbed)) {
3951 absorbable = true;
3952 }
3953 opConLinkerIt = opConLinkerIt->getNext();
3954 }
3955 }
3956 } else if (negated && (opCode == CCAND) || !negated && opCode == CCOR) {
3957 // OR, all operands have to be triggerable
3958 if (opCount >= 1) {
3959 bool allOpsTriggerable = true;
3960 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
3961 while (opConLinkerIt && allOpsTriggerable) {
3962 CConcept* opConcept = opConLinkerIt->getData();
3963 bool opNegated = opConLinkerIt->isNegated()^negated;
3964 allOpsTriggerable &= isConceptPartialImplicationTriggerable(opConcept,opNegated,conceptEqConAbsorbed);
3965 opConLinkerIt = opConLinkerIt->getNext();
3966 }
3967 absorbable = allOpsTriggerable;
3968 }
3969 } else if (opCode == CCEQ) {
3970 if (negated) {
3971 absorbable = false;
3972 } else {
3973 if (conceptEqConAbsorbed->contains(concept)) {
3974 mEQNotConceptPartialAbsorbableSet.insert(concept);
3975 return false;
3976 } else {
3977 // AND, at least one operand has to be triggerable
3978 if (opCount >= 1) {
3979 conceptEqConAbsorbed->insert(concept);
3980 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
3981 while (opConLinkerIt) {
3982 CConcept* opConcept = opConLinkerIt->getData();
3983 bool opNegated = opConLinkerIt->isNegated()^negated;
3984 if (isConceptPartialImplicationTriggerable(opConcept,opNegated,conceptEqConAbsorbed)) {
3985 absorbable = true;
3986 }
3987 opConLinkerIt = opConLinkerIt->getNext();
3988 }
3989 }
3990 if (mEQNotConceptPartialAbsorbableSet.contains(concept)) {
3991 absorbable = false;
3992 }
3993 }
3994 }
3995 } else if (!negated && (opCode == CCDATALITERAL)) {
3996 if (mConfDatatypeAbsorption) {
3997 CDataLiteral* dataLiteral = concept->getDataLiteral();
3998 if (dataLiteral) {
3999 CDataLiteralValue* dataLitValue = dataLiteral->getDataLiteralValue();
4000 if (dataLitValue) {
4001 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_REAL) {
4002 absorbable = true;
4003 }
4004 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_STRING) {
4005 absorbable = true;
4006 }
4007 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_BOOLEAN) {
4008 absorbable = true;
4009 }
4010 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_DOUBLE) {
4011 absorbable = true;
4012 }
4013 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_FLOAT) {
4014 absorbable = true;
4015 }
4016 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_IRI) {
4017 absorbable = true;
4018 }
4019 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_XML) {
4020 absorbable = true;
4021 }
4022 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_HEXBINARY) {
4023 absorbable = true;
4024 }
4025 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_BASE64BINARY) {
4026 absorbable = true;
4027 }
4028 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_DATETIME) {
4029 absorbable = true;
4030 }
4031 }
4032 }
4033 }
4034 } else if (!negated && (opCode == CCDATARESTRICTION)) {
4035 if (mConfDatatypeAbsorption) {
4036 cint64 dataRestrictionType = parm;
4037 CDatatype* datatype = concept->getDatatype();
4038 if (datatype->isBasicDatatype()) {
4039 CDatatype::DATATYPE_BASIC_TYPE datatypeType = datatype->getBasicDatatypeType();
4040 if (datatypeType == CDatatype::DBT_REAL) {
4041 if (dataRestrictionType == CDFC_RATIONAL) {
4042 absorbable = true;
4043 } else if (dataRestrictionType == CDFC_DECIMAL) {
4044 absorbable = true;
4045 } else if (dataRestrictionType == CDFC_INTEGER) {
4046 absorbable = true;
4047 }
4048 }
4049 if (datatypeType == CDatatype::DBT_STRING) {
4050 if (dataRestrictionType == CDFC_STRING) {
4051 absorbable = true;
4052 }
4053 }
4054 if (datatypeType == CDatatype::DBT_REAL || datatypeType == CDatatype::DBT_STRING || datatypeType == CDatatype::DBT_BOOLEAN || datatypeType == CDatatype::DBT_DOUBLE || datatypeType == CDatatype::DBT_DATETIME
4055 || datatypeType == CDatatype::DBT_FLOAT || datatypeType == CDatatype::DBT_IRI || datatypeType == CDatatype::DBT_XML || datatypeType == CDatatype::DBT_HEXBINARY || datatypeType == CDatatype::DBT_BASE64BINARY) {
4056
4057 CDataLiteral* dataLiteral = concept->getDataLiteral();
4058 if (!dataLiteral || !dataLiteral->getDatatype() || !dataLiteral->getDataLiteralValue() || dataLiteral->getDatatype()->getValueSpaceType() != datatype->getValueSpaceType()) {
4059 absorbable = false;
4060 } else {
4061 if (dataRestrictionType == CDFC_MIN_EXCLUSIVE) {
4062 absorbable = true;
4063 } else if (dataRestrictionType == CDFC_MIN_INCLUSIVE) {
4064 absorbable = true;
4065 } else if (dataRestrictionType == CDFC_MAX_INCLUSIVE) {
4066 absorbable = true;
4067 } else if (dataRestrictionType == CDFC_MAX_EXCLUSIVE) {
4068 absorbable = true;
4069 }
4070 }
4071 }
4072 }
4073 }
4074 } else if (!negated && (opCode == CCDATATYPE)) {
4075
4076 if (mConfDatatypeAbsorption) {
4077 CDatatype* datatype = concept->getDatatype();
4078 if (datatype->isBasicDatatype()) {
4079 CDatatype::DATATYPE_BASIC_TYPE datatypeType = datatype->getBasicDatatypeType();
4080 if (datatypeType == CDatatype::DBT_REAL || datatypeType == CDatatype::DBT_STRING || datatypeType == CDatatype::DBT_BOOLEAN || datatypeType == CDatatype::DBT_DOUBLE || datatypeType == CDatatype::DBT_DATETIME
4081 || datatypeType == CDatatype::DBT_FLOAT || datatypeType == CDatatype::DBT_IRI || datatypeType == CDatatype::DBT_XML || datatypeType == CDatatype::DBT_HEXBINARY || datatypeType == CDatatype::DBT_BASE64BINARY) {
4082 absorbable = true;
4083 }
4084 } else {
4085
4086 if (opCount >= 1) {
4087 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
4088 while (opConLinkerIt) {
4089 CConcept* opConcept = opConLinkerIt->getData();
4090 bool opNegated = opConLinkerIt->isNegated()^negated;
4091 if (isConceptPartialImplicationTriggerable(opConcept,opNegated,conceptEqConAbsorbed)) {
4092 absorbable = true;
4093 }
4094 opConLinkerIt = opConLinkerIt->getNext();
4095 }
4096 }
4097 }
4098 }
4099
4100
4101 } else {
4102 absorbable = false;
4103 }
4104 mConceptPartialAbsorbableHash.insert(conNegPair,absorbable);
4105 return absorbable;
4106 }
4107
4108
4109
4110
4111
4112 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createPartialExtendedAbsorbedImpliedTriggerCocnept(const QList<TConceptNegationPair>& absorbList) {
4113 CConceptTriggerLinker* trigger = createPartialExtendedAbsorbedImpliedTrigger(absorbList);
4114 if (trigger) {
4115 return trigger->getTriggerConcept();
4116 }
4117 return nullptr;
4118 }
4119
4120
4121 CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::createPartialExtendedAbsorbedImpliedTrigger(const QList<TConceptNegationPair>& absorbList) {
4122 CConceptTriggerLinker* triggers = nullptr;
4123 for (QList<TConceptNegationPair>::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
4124 TConceptNegationPair conNegPair(*it);
4125 CConcept* concept = conNegPair.first;
4126 bool negated = conNegPair.second;
4127 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept,!negated));
4128 triggers = tmpTriggers->append(triggers);
4129 }
4130 CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers,nullptr);
4131 return impliedConceptTrigger;
4132 }
4133
4134
4135 CConcept* CTriggeredImplicationBinaryAbsorberPreProcess::createPartialExtendedAbsorbedTriggeredImplication(CConcept* impliedConcept, bool impliedNegation, const QList<TConceptNegationPair>& absorbList) {
4136 CConcept* implicationConcept = nullptr;
4137 CConceptTriggerLinker* triggers = nullptr;
4138 for (QList<TConceptNegationPair>::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
4139 TConceptNegationPair conNegPair(*it);
4140 CConcept* concept = conNegPair.first;
4141 bool negated = conNegPair.second;
4142 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getPartialTriggersForConcept(concept,!negated));
4143 triggers = tmpTriggers->append(triggers);
4144 }
4145 CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers,&implicationConcept);
4146 addUnfoldingConceptForConcept(impliedConceptTrigger->getTriggerConcept(),impliedConcept,impliedNegation);
4147 return implicationConcept;
4148 }
4149
4150
4151
4152 void CTriggeredImplicationBinaryAbsorberPreProcess::createGCIAbsorbedTriggeredImplication(CConcept* orConcept, bool negated, QList<TConceptNegationPair>& absorbList, QList<TConceptNegationPair>& candList) {
4153 CConcept* impliedConcept = nullptr;
4154 bool impliedNegation = false;
4155
4156 if (candList.isEmpty()) {
4157 candList.append(TConceptNegationPair(mTopConcept,true));
4158 }
4159
4160 CConceptTriggerLinker* triggers = nullptr;
4161 for (QList<TConceptNegationPair>::const_iterator it = absorbList.constBegin(), itEnd = absorbList.constEnd(); it != itEnd; ++it) {
4162 TConceptNegationPair conNegPair(*it);
4163 CConcept* concept = conNegPair.first;
4164 bool negated = conNegPair.second;
4165 CConceptTriggerLinker* tmpTriggers = copyTriggerLinkers(getTriggersForConcept(concept,!negated));
4166 triggers = tmpTriggers->append(triggers);
4167 }
4168
4169 CConcept* partialImpliedTriggerConcept = nullptr;
4170 QList<TConceptNegationPair> partialAbsorbableList;
4171 if (candList.count() > 1) {
4172 if (mConfPartialGCIAbsorption) {
4173 partialAbsorbableList = getPartialAbsorbableDisjuncts(candList);
4174 if (!partialAbsorbableList.isEmpty()) {
4175 CConceptTriggerLinker* partialImpliedTrigger = createPartialExtendedAbsorbedImpliedTrigger(partialAbsorbableList);
4176 partialImpliedTriggerConcept = partialImpliedTrigger->getTriggerConcept();
4177 triggers = partialImpliedTrigger->append(triggers);
4178 }
4179 }
4180 }
4181
4182 CConceptTriggerLinker* impliedConceptTrigger = getImplicationTriggeredConceptForTriggers(triggers,nullptr);
4183 impliedConcept = impliedConceptTrigger->getTriggerConcept();
4184 if (candList.count() > 1) {
4185
4186
4187 CConcept* orImpliedConcept = createImpliedConcept();
4188 for (QList<TConceptNegationPair>::const_iterator it = candList.constBegin(), itEnd = candList.constEnd(); it != itEnd; ++it) {
4189 TConceptNegationPair conNegPair(*it);
4190 CConcept* concept = conNegPair.first;
4191 bool negated = conNegPair.second;
4192 addConceptToImplied(orImpliedConcept,concept,negated);
4193 }
4194 orImpliedConcept->setOperatorCode(CCOR);
4195 addUnfoldingConceptForConcept(impliedConcept,orImpliedConcept,false);
4196
4197 if (partialImpliedTriggerConcept) {
4198 CConceptRoleBranchingTrigger* branchTriggers = getSimpleBranchTriggersForConcept(partialImpliedTriggerConcept,true);
4199 mBranchTriggVec->setData(impliedConcept->getConceptTag(),branchTriggers);
4200 ++mStatGCIAbsorptionPartialExtended;
4201
4202 if (partialAbsorbableList.count() + 1 == candList.count()) {
4203 QList<TConceptNegationPair> allList(candList);
4204 allList.append(absorbList);
4205 QList<TConceptNegationPair> assurList(getAssuringAbsorbableDisjuncts(allList));
4206 if (assurList.count() + 1 == allList.count()) {
4207 ++mStatGCIAbsorptionAssuring;
4208 createGCIAssuringAbsorbedTriggeredImplication(orConcept, negated, assurList, candList);
4209 }
4210 }
4211
4212 }
4213 } else {
4214 TConceptNegationPair conNegPair(candList.first());
4215 CConcept* concept = conNegPair.first;
4216 bool negated = conNegPair.second;
4217 addUnfoldingConceptForConcept(impliedConcept,concept,negated);
4218 }
4219 }
4220
4221
4222
4223 CConceptRoleBranchingTrigger* CTriggeredImplicationBinaryAbsorberPreProcess::getBranchTiggers(CConceptTriggerLinker* triggers) {
4224 CConceptRoleBranchingTrigger* branchingTriggerLinker = nullptr;
4225 for (CConceptTriggerLinker* triggerIt = triggers; triggerIt; triggerIt = triggerIt->getNext()) {
4226 CConceptRoleBranchingTrigger* branchingTrigger = nullptr;
4227 branchingTrigger = CObjectAllocator< CConceptRoleBranchingTrigger >::allocateAndConstruct(mMemMan);
4228 branchingTrigger->initConceptBranchingTrigger(triggerIt->getTriggerConcept(),false);
4229 branchingTriggerLinker = branchingTrigger->append(branchingTriggerLinker);
4230 }
4231 return branchingTriggerLinker;
4232 }
4233
4234
4235 CConceptRoleBranchingTrigger* CTriggeredImplicationBinaryAbsorberPreProcess::getSimpleBranchTriggersForConcept(CConcept* concept, bool negated) {
4236 CConceptRoleBranchingTrigger* branchingTrigger = nullptr;
4237 cint64 conOpCount = concept->getOperandCount();
4238
4239 qint64 conOpCode = concept->getOperatorCode();
4240
4241 if ((conOpCode == CCSUB || conOpCode == CCATOM || conOpCode == CCIMPLTRIG) && !negated) {
4242 branchingTrigger = CObjectAllocator< CConceptRoleBranchingTrigger >::allocateAndConstruct(mMemMan);
4243 branchingTrigger->initConceptBranchingTrigger(concept,false);
4244 } else if (conOpCode == CCALL && !negated || conOpCode == CCSOME && negated || conOpCode == CCATMOST && !negated || conOpCode == CCATLEAST && negated && conOpCount > 0) {
4245 CRole* role = concept->getRole();
4246 CRole* locatedRole = CConceptRoleIndividualLocator::getLocatedRole(role,mOnto);
4247 CConcept* triggerConcept = getRoleDomainTriggerConcept(locatedRole);
4248 branchingTrigger = CObjectAllocator< CConceptRoleBranchingTrigger >::allocateAndConstruct(mMemMan);
4249 branchingTrigger->initConceptBranchingTrigger(triggerConcept,false);
4250 }
4251
4252 return branchingTrigger;
4253 }
4254
4255
4256
4257 CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getPartialTriggersForConcept(CConcept* concept, bool negated, CConcept* backPropConcept) {
4258 CConceptTriggerLinker* triggers = nullptr;
4259
4260 CConcept* backPropImpConcept = nullptr;
4261 CConcept* backPropTriggerConcept = nullptr;
4262 CConcept** backPropImpConceptPointer = nullptr;
4263 bool branchTiggerCreation = false;
4264 if (backPropConcept) {
4265 backPropImpConceptPointer = &backPropImpConcept;
4266 branchTiggerCreation = true;
4267 }
4268 TConceptNegationPair conNegPair(concept,negated);
4269 triggers = mConceptTriggerLinkerHash.value(conNegPair);
4270 if (triggers && backPropConcept) {
4271 CConcept* backPropActivCon = mBackPropActivationConHash.value(conNegPair);
4272 if (backPropActivCon) {
4273 addUnfoldingConceptForConcept(backPropConcept, backPropActivCon, false);
4274 }
4275 }
4276 if (!triggers) {
4277 if (backPropConcept) {
4278 backPropTriggerConcept = createTriggerConcept(branchTiggerCreation);
4279 addUnfoldingConceptForConcept(backPropConcept, backPropTriggerConcept, false);
4280 }
4281
4282 cint64 opCode = concept->getOperatorCode();
4283 cint64 parm = concept->getParameter();
4284 cint64 opCount = concept->getOperandCount();
4285 CRole* role = concept->getRole();
4286 CSortedNegLinker<CConcept*>* opConLinker = concept->getOperandList();
4287
4288 if (!negated && (opCode == CCATOM || opCode == CCSUB|| opCode == CCTOP || opCode == CCIMPLTRIG)) {
4289 CConceptTriggerLinker* newTrigger = createTriggerLinker();
4290 newTrigger->initConceptTriggerLinker(concept, 1);
4291 if (backPropConcept) {
4292 CConceptTriggerLinker* implTriggeredConcept = getImplicationTriggeredConceptForTriggers(newTrigger, backPropImpConceptPointer);
4293 addUnfoldingConceptForConcept(backPropTriggerConcept, backPropImpConcept, false);
4294 newTrigger = implTriggeredConcept;
4295 }
4296 triggers = newTrigger->append(triggers);
4297
4298
4299 } else if (negated && (opCode == CCOR) || !negated && (opCode == CCAND || opCode == CCEQ)) {
4300 // AND, collect triggers from operands
4301
4302 if (opCode != CCEQ || !mEQNotConceptPartialAbsorbableSet.contains(concept)) {
4303
4304 CConceptTriggerLinker* andTriggers = nullptr;
4305 for (CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
4306 CConcept* opConcept = opConLinkerIt->getData();
4307 bool opNegated = opConLinkerIt->isNegated()^negated;
4308
4309 if (mConceptPartialAbsorbableHash.value(TConceptNegationPair(opConcept,opNegated),false) || mConceptTotalAbsorbableHash.value(TConceptNegationPair(opConcept,opNegated),false)) {
4310 CConceptTriggerLinker* newTriggers = copyTriggerLinkers(getPartialTriggersForConcept(opConcept,opNegated, backPropTriggerConcept));
4311 if (newTriggers) {
4312 andTriggers = newTriggers->append(andTriggers);
4313 }
4314 }
4315 }
4316 if (opCode == CCEQ || backPropConcept) {
4317 CConceptTriggerLinker* implTriggers = getImplicationTriggeredConceptForTriggers(andTriggers,backPropImpConceptPointer);
4318 if (backPropConcept) {
4319 addUnfoldingConceptForConcept(backPropTriggerConcept, backPropImpConcept, false);
4320 }
4321 andTriggers = implTriggers;
4322 }
4323 if (andTriggers) {
4324 triggers = andTriggers->append(triggers);
4325 }
4326 }
4327
4328
4329 } else if (!negated && (opCode == CCOR) || negated && (opCode == CCAND || opCode == CCEQ)) {
4330 // or trigger
4331 CConceptTriggerLinker* orTriggers = nullptr;
4332 for (CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
4333 CConcept* opConcept = opConLinkerIt->getData();
4334 bool opNegated = opConLinkerIt->isNegated()^negated;
4335
4336 CConceptTriggerLinker* newTriggers = copyTriggerLinkers(getPartialTriggersForConcept(opConcept,opNegated, backPropTriggerConcept));
4337 if (newTriggers) {
4338 CConceptTriggerLinker* implTriggeredConcept = getImplicationTriggeredConceptForTriggers(newTriggers, backPropImpConceptPointer);
4339 if (backPropImpConceptPointer) {
4340 addUnfoldingConceptForConcept(backPropTriggerConcept, backPropImpConcept, false);
4341 }
4342 orTriggers = implTriggeredConcept->append(orTriggers);
4343 }
4344 }
4345 if (orTriggers) {
4346 if (orTriggers->hasNext()) {
4347 // more than one trigger
4348 cint64 minTriggerComplexity = 0;
4349 CConcept* triggerConcept = createTriggerConcept(branchTiggerCreation);
4350 for (CConceptTriggerLinker* orTriggerIt = orTriggers; orTriggerIt; orTriggerIt = orTriggerIt->getNext()) {
4351 minTriggerComplexity = qMin(orTriggerIt->getTriggerComplexity(),minTriggerComplexity);
4352 addUnfoldingConceptForConcept(orTriggerIt->getTriggerConcept(),triggerConcept,false);
4353 }
4354 CConceptTriggerLinker* newTrigger = createTriggerLinker();
4355 newTrigger->initConceptTriggerLinker(triggerConcept,minTriggerComplexity);
4356 triggers = newTrigger->append(triggers);
4357 //releaseTriggerLinkers(orTriggers);
4358 } else {
4359 // only one trigger, add simply to other triggers
4360 triggers = orTriggers->append(triggers);
4361 }
4362 }
4363
4364 } else if (opCode == CCAQCHOOCE) {
4365
4366 CConceptTriggerLinker* andTriggers = nullptr;
4367 for (CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
4368 CConcept* opConcept = opConLinkerIt->getData();
4369 bool opNegated = opConLinkerIt->isNegated();
4370
4371 if (opNegated == negated) {
4372 if (mConceptPartialAbsorbableHash.value(TConceptNegationPair(opConcept, opNegated), false) || mConceptTotalAbsorbableHash.value(TConceptNegationPair(opConcept, opNegated), false)) {
4373 CConceptTriggerLinker* newTriggers = copyTriggerLinkers(getPartialTriggersForConcept(opConcept, opNegated, backPropTriggerConcept));
4374 if (newTriggers) {
4375 andTriggers = newTriggers->append(andTriggers);
4376 }
4377 }
4378 }
4379 }
4380 if (backPropConcept) {
4381 CConceptTriggerLinker* implTriggers = getImplicationTriggeredConceptForTriggers(andTriggers, backPropImpConceptPointer);
4382 if (backPropConcept) {
4383 addUnfoldingConceptForConcept(backPropTriggerConcept, backPropImpConcept, false);
4384 }
4385 andTriggers = implTriggers;
4386 }
4387 if (andTriggers) {
4388 triggers = andTriggers->append(triggers);
4389 }
4390
4391
4392 } else if (!negated && (opCode == CCSOME || opCode == CCSELF || opCode == CCAQSOME) || negated && (opCode == CCALL) ||
4393 !negated && (opCode == CCATLEAST) || negated && (opCode == CCATMOST)) {
4394 CConcept* propagatedTriggerConcept = nullptr;
4395 cint64 triggerComplexity = 1;
4396 bool negateOperands = negated && (opCode == CCSOME || opCode == CCSELF || opCode == CCALL);
4397 CConceptTriggerLinker* allTriggers = nullptr;
4398 CConcept* roleBackPropTriggerConcept = nullptr;
4399 if (backPropConcept) {
4400 roleBackPropTriggerConcept = createTriggerConcept(branchTiggerCreation);
4401 CConcept* roleBackPropConcept = createTriggerPropagationConcept(roleBackPropTriggerConcept, role, branchTiggerCreation, false);
4402 addUnfoldingConceptForConcept(backPropTriggerConcept, roleBackPropConcept, false);
4403 }
4404 for (CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
4405 CConcept* opConcept = opConLinkerIt->getData();
4406 bool opNegated = opConLinkerIt->isNegated()^negateOperands;
4407 if (!(!opNegated && opConcept == mTopConcept || opNegated && opConcept == mBottomConcept)) {
4408 if (mConceptPartialAbsorbableHash.value(TConceptNegationPair(opConcept,opNegated),false) || mConceptTotalAbsorbableHash.value(TConceptNegationPair(opConcept,opNegated),false)) {
4409 CConceptTriggerLinker* newTrigger = copyTriggerLinkers(getPartialTriggersForConcept(opConcept,opNegated, roleBackPropTriggerConcept));
4410 if (newTrigger) {
4411 allTriggers = newTrigger->append(allTriggers);
4412 }
4413 }
4414 }
4415 }
4416 if (allTriggers) {
4417 propagatedTriggerConcept = createTriggerConcept(branchTiggerCreation);
4418 CConcept* nextLevelTriggerConcept = createTriggerPropagationConcept(propagatedTriggerConcept,role, branchTiggerCreation);
4419 if (allTriggers->hasNext()) {
4420 // requires a generation of an implication concept
4421 CConceptTriggerLinker* implTriggeredConcept = getImplicationTriggeredConceptForTriggers(allTriggers, backPropImpConceptPointer);
4422 if (backPropImpConceptPointer) {
4423 addUnfoldingConceptForConcept(roleBackPropTriggerConcept, backPropImpConcept, false);
4424 }
4425 triggerComplexity += implTriggeredConcept->getTriggerComplexity();
4426 addUnfoldingConceptForConcept(implTriggeredConcept->getTriggerConcept(),nextLevelTriggerConcept,false);
4427 } else {
4428 triggerComplexity += allTriggers->getTriggerComplexity();
4429 addUnfoldingConceptForConcept(allTriggers->getTriggerConcept(),nextLevelTriggerConcept,false);
4430 releaseTriggerLinkers(allTriggers);
4431 }
4432 } else {
4433 if (backPropConcept) {
4434 propagatedTriggerConcept = createTriggerConcept(branchTiggerCreation);
4435 CConcept* nextLevelTriggerConcept = createTriggerPropagationConcept(propagatedTriggerConcept, role, branchTiggerCreation);
4436 addUnfoldingConceptForConcept(roleBackPropTriggerConcept, nextLevelTriggerConcept, false);
4437 } else {
4438 CRole* locatedRole = CConceptRoleIndividualLocator::getLocatedRole(role, mOnto);
4439 propagatedTriggerConcept = getRoleDomainTriggerConcept(locatedRole);
4440 }
4441 }
4442 CConceptTriggerLinker* newTrigger = createTriggerLinker();
4443 newTrigger->initConceptTriggerLinker(propagatedTriggerConcept,triggerComplexity);
4444 triggers = newTrigger->append(triggers);
4445
4446
4447 } else if (!negated && (opCode == CCVALUE)) {
4448
4449
4450 CIndividual* individual = concept->getNominalIndividual();
4451
4452 CConcept* propagatedTriggerConcept = createTriggerConcept(branchTiggerCreation);
4453 CConcept* nextLevelTriggerConcept = createTriggerPropagationConcept(propagatedTriggerConcept,role, branchTiggerCreation);
4454
4455 cint64 triggerComplexity = 2;
4456
4457
4458
4459 if (!backPropConcept) {
4460 CIndividual* locatedIndividual = CConceptRoleIndividualLocator::getLocatedIndividual(individual, mOnto);
4461 CConceptAssertionLinker* assLinker = CObjectAllocator< CConceptAssertionLinker >::allocateAndConstruct(mMemMan);
4462 assLinker->initNegLinker(nextLevelTriggerConcept,false);
4463 locatedIndividual->addAssertionConceptLinker(assLinker);
4464
4465 if (!mIndividualTriggerConceptHash) {
4466 mIndividualTriggerConceptHash = mTBox->getIndividualTriggerConceptHash(true);
4467 }
4468 mIndividualTriggerConceptHash->insertMulti(individual->getIndividualID(),nextLevelTriggerConcept);
4469 } else {
4470 CConcept* roleBackPropTriggerConcept = createTriggerConcept(branchTiggerCreation);
4471 CConcept* roleBackPropConcept = createTriggerPropagationConcept(roleBackPropTriggerConcept, role, branchTiggerCreation, false);
4472 addUnfoldingConceptForConcept(backPropTriggerConcept, roleBackPropConcept, false);
4473
4474 CConcept* nomImpConcept = createNominalImplication(nextLevelTriggerConcept, individual);
4475 addUnfoldingConceptForConcept(roleBackPropTriggerConcept, nomImpConcept, false);
4476
4477 }
4478
4479 CConceptTriggerLinker* newTrigger = createTriggerLinker();
4480 newTrigger->initConceptTriggerLinker(propagatedTriggerConcept,triggerComplexity);
4481 triggers = newTrigger->append(triggers);
4482
4483 } else if (!negated && (opCode == CCNOMVAR)) {
4484 cint64 triggerComplexity = 1;
4485 CConcept* nominalTriggerConcept = mTBox->getIndividualTriggerConcept();
4486 CConceptTriggerLinker* newTrigger = createTriggerLinker();
4487 newTrigger->initConceptTriggerLinker(nominalTriggerConcept,triggerComplexity);
4488 triggers = newTrigger->append(triggers);
4489
4490 } else if (!negated && (opCode == CCNOMINAL)) {
4491 CConcept* nominalTriggerConcept = createTriggerConcept(branchTiggerCreation);
4492 cint64 triggerComplexity = 1;
4493
4494 CIndividual* individual = concept->getNominalIndividual();
4495 if (!backPropConcept) {
4496 CIndividual* locatedIndividual = CConceptRoleIndividualLocator::getLocatedIndividual(individual, mOnto);
4497 CConceptAssertionLinker* assLinker = CObjectAllocator< CConceptAssertionLinker >::allocateAndConstruct(mMemMan);
4498 assLinker->initNegLinker(nominalTriggerConcept,false);
4499 locatedIndividual->addAssertionConceptLinker(assLinker);
4500
4501 if (!mIndividualTriggerConceptHash) {
4502 mIndividualTriggerConceptHash = mTBox->getIndividualTriggerConceptHash(true);
4503 }
4504 mIndividualTriggerConceptHash->insertMulti(individual->getIndividualID(),nominalTriggerConcept);
4505 } else {
4506 CConcept* nomImpConcept = createNominalImplication(nominalTriggerConcept, individual);
4507 addUnfoldingConceptForConcept(backPropTriggerConcept, nomImpConcept, false);
4508 }
4509
4510
4511 CConceptTriggerLinker* newTrigger = createTriggerLinker();
4512 newTrigger->initConceptTriggerLinker(nominalTriggerConcept,triggerComplexity);
4513 triggers = newTrigger->append(triggers);
4514
4515
4516 } else if (!negated && (opCode == CCDATALITERAL)) {
4517 if (mConfDatatypeAbsorption) {
4518 CDataLiteral* dataLiteral = concept->getDataLiteral();
4519 if (dataLiteral) {
4520 CDataLiteralValue* dataLitValue = dataLiteral->getDataLiteralValue();
4521 if (dataLitValue) {
4522
4523 cint64 triggerComplexity = 2;
4524 CConcept* valueTriggerConcept = createTriggerConcept(branchTiggerCreation);
4525 CConceptTriggerLinker* valueTrigger = createTriggerLinker();
4526 valueTrigger->initConceptTriggerLinker(valueTriggerConcept,triggerComplexity);
4527 CDatatypeValueSpaceConceptTriggerLinker* valueSpaceConceptTriggerLinker = createValueSpaceConceptTriggerLinker();
4528 valueSpaceConceptTriggerLinker->initConceptTrigger(valueTriggerConcept);
4529
4530
4531 if (backPropConcept) {
4532 CConcept* datatypeImpConcept = createDataLiteralImplication(valueTriggerConcept, dataLiteral);
4533 addUnfoldingConceptForConcept(backPropTriggerConcept, datatypeImpConcept, false);
4534 } else {
4535
4536
4537 CDatatypeValueSpaceTriggers* valueSpaceTrigger = nullptr;
4538 CDataLiteralValue* dataLitValue = dataLiteral->getDataLiteralValue();
4539 if (dataLitValue) {
4540 CDataLiteralCompareValue* compareDataLitValue = dynamic_cast<CDataLiteralCompareValue*>(dataLitValue);
4541 if (compareDataLitValue) {
4542 CDatatypeValueSpaceType* valueSpaceType = nullptr;
4543 CDataLiteralValue::DATA_LITERAL_VALUE_TYPE dataLiteralValueType = compareDataLitValue->getDataValueType();
4544 CDatatypeValueSpaceTypes* valueSpaceTypes = CDatatypeValueSpaceTypes::getValueSpaceTypes();
4545 if (dataLiteralValueType == CDataLiteralValue::DLVT_REAL) {
4546 valueSpaceType = valueSpaceTypes->getValueSpaceRealType();
4547 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_STRING) {
4548 valueSpaceType = valueSpaceTypes->getValueSpaceStringType();
4549 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_BOOLEAN) {
4550 valueSpaceType = valueSpaceTypes->getValueSpaceBooleanType();
4551 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_DOUBLE) {
4552 valueSpaceType = valueSpaceTypes->getValueSpaceDoubleType();
4553 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_FLOAT) {
4554 valueSpaceType = valueSpaceTypes->getValueSpaceFloatType();
4555 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_IRI) {
4556 valueSpaceType = valueSpaceTypes->getValueSpaceIRIType();
4557 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_XML) {
4558 valueSpaceType = valueSpaceTypes->getValueSpaceXMLType();
4559 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_HEXBINARY) {
4560 valueSpaceType = valueSpaceTypes->getValueSpaceBinaryHexDataType();
4561 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_BASE64BINARY) {
4562 valueSpaceType = valueSpaceTypes->getValueSpaceBinaryBase64DataType();
4563 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_DATETIME) {
4564 valueSpaceType = valueSpaceTypes->getValueSpaceDateTimeType();
4565 }
4566
4567 if (valueSpaceType) {
4568 CDatatypeValueSpacesTriggers* valueSpacesTriggers = mMBox->getValueSpacesTriggers(true);
4569 CDatatypeValueSpaceCompareTriggers* compareValueSpaceConceptTrigger = (CDatatypeValueSpaceCompareTriggers*)valueSpacesTriggers->getValueSpaceTriggers(valueSpaceType);
4570 if (compareValueSpaceConceptTrigger) {
4571 compareValueSpaceConceptTrigger->addPartialValueConceptTrigger(compareDataLitValue, valueSpaceConceptTriggerLinker);
4572 }
4573 }
4574 }
4575 }
4576 }
4577
4578 triggers = valueTrigger->append(triggers);
4579
4580 }
4581 }
4582 }
4583
4584
4585
4586 } else if (!negated && (opCode == CCDATATYPE)) {
4587 if (mConfDatatypeAbsorption) {
4588 CDatatype* datatype = concept->getDatatype();
4589 if (datatype && datatype->isBasicDatatype()) {
4590
4591 cint64 triggerComplexity = 1;
4592 CConcept* valueTriggerConcept = createTriggerConcept(branchTiggerCreation);
4593 CConceptTriggerLinker* valueTrigger = createTriggerLinker();
4594 valueTrigger->initConceptTriggerLinker(valueTriggerConcept,triggerComplexity);
4595 CDatatypeValueSpaceConceptTriggerLinker* valueSpaceConceptTriggerLinker = createValueSpaceConceptTriggerLinker();
4596 valueSpaceConceptTriggerLinker->initConceptTrigger(valueTriggerConcept);
4597
4598
4599 if (backPropConcept) {
4600 CConcept* datatypeImpConcept = createDatatypeImplication(valueTriggerConcept, datatype);
4601 addUnfoldingConceptForConcept(backPropTriggerConcept, datatypeImpConcept, false);
4602 } else {
4603
4604
4605 CDatatypeValueSpaceTriggers* valueSpaceTrigger = nullptr;
4606
4607 CDatatypeValueSpaceType* valueSpaceType = datatype->getValueSpaceType();
4608
4609 if (valueSpaceType) {
4610 CDatatypeValueSpacesTriggers* valueSpacesTriggers = mMBox->getValueSpacesTriggers(true);
4611 CDatatypeValueSpaceCompareTriggers* compareValueSpaceConceptTrigger = (CDatatypeValueSpaceCompareTriggers*)valueSpacesTriggers->getValueSpaceTriggers(valueSpaceType);
4612 if (compareValueSpaceConceptTrigger) {
4613 compareValueSpaceConceptTrigger->addValueSpaceConceptTrigger(valueSpaceConceptTriggerLinker);
4614 }
4615 }
4616 }
4617
4618 triggers = valueTrigger->append(triggers);
4619 } else {
4620
4621 CConceptTriggerLinker* andTriggers = nullptr;
4622 for (CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
4623 CConcept* opConcept = opConLinkerIt->getData();
4624 bool opNegated = opConLinkerIt->isNegated()^negated;
4625
4626 if (mConceptPartialAbsorbableHash.value(TConceptNegationPair(opConcept,opNegated),false) || mConceptTotalAbsorbableHash.value(TConceptNegationPair(opConcept,opNegated),false)) {
4627 CConceptTriggerLinker* newTriggers = copyTriggerLinkers(getPartialTriggersForConcept(opConcept,opNegated, backPropTriggerConcept));
4628 if (newTriggers) {
4629 CConceptTriggerLinker* implTriggers = getImplicationTriggeredConceptForTriggers(newTriggers, backPropImpConceptPointer);
4630 if (backPropConcept) {
4631 addUnfoldingConceptForConcept(backPropTriggerConcept, backPropImpConcept, false);
4632 }
4633 andTriggers = newTriggers->append(andTriggers);
4634 }
4635 }
4636 }
4637 if (andTriggers) {
4638 triggers = andTriggers->append(triggers);
4639 }
4640 }
4641 }
4642
4643
4644
4645 } else if (!negated && (opCode == CCDATARESTRICTION)) {
4646 if (mConfDatatypeAbsorption) {
4647 CDatatype* datatype = concept->getDatatype();
4648 if (datatype && datatype->isBasicDatatype()) {
4649 cint64 dataRestrictionCode = parm;
4650
4651 cint64 triggerComplexity = 1;
4652 CConcept* valueTriggerConcept = createTriggerConcept(branchTiggerCreation);
4653 CConceptTriggerLinker* valueTrigger = createTriggerLinker();
4654 valueTrigger->initConceptTriggerLinker(valueTriggerConcept, triggerComplexity);
4655 CDatatypeValueSpaceConceptTriggerLinker* valueSpaceConceptTriggerLinker = createValueSpaceConceptTriggerLinker();
4656 valueSpaceConceptTriggerLinker->initConceptTrigger(valueTriggerConcept);
4657 CDataLiteral* dataLiteral = concept->getDataLiteral();
4658
4659 if (backPropConcept) {
4660 CConcept* datatypeImpConcept = createDataRestrictionImplication(valueTriggerConcept, datatype, dataLiteral, dataRestrictionCode);
4661 addUnfoldingConceptForConcept(backPropTriggerConcept, datatypeImpConcept, false);
4662 } else {
4663
4664 CDatatypeValueSpacesTriggers* valueSpacesTriggers = mMBox->getValueSpacesTriggers(true);
4665
4666 CDatatype::DATATYPE_BASIC_TYPE basicDatatype = datatype->getBasicDatatypeType();
4667 if (basicDatatype == CDatatype::DBT_REAL) {
4668 CDatatypeValueSpaceRealTriggers* realValueSpaceConceptTrigger = valueSpacesTriggers->getRealValueSpaceTriggers();
4669 if (dataRestrictionCode == CDFC_RATIONAL) {
4670 realValueSpaceConceptTrigger->addRationalConceptTrigger(valueSpaceConceptTriggerLinker);
4671 } else if (dataRestrictionCode == CDFC_DECIMAL) {
4672 realValueSpaceConceptTrigger->addDecimalConceptTrigger(valueSpaceConceptTriggerLinker);
4673 } else if (dataRestrictionCode == CDFC_INTEGER) {
4674 realValueSpaceConceptTrigger->addIntegerConceptTrigger(valueSpaceConceptTriggerLinker);
4675 }
4676 }
4677 if (basicDatatype == CDatatype::DBT_STRING) {
4678 CDatatypeValueSpaceStringTriggers* stringValueSpaceConceptTrigger = valueSpacesTriggers->getStringValueSpaceTriggers();
4679 if (dataRestrictionCode == CDFC_STRING) {
4680 stringValueSpaceConceptTrigger->addNonLanguageTagConceptTrigger(valueSpaceConceptTriggerLinker);
4681 }
4682 }
4683 if (dataLiteral) {
4684 CDataLiteralValue* dataLitValue = dataLiteral->getDataLiteralValue();
4685 if (dataLitValue) {
4686 CDataLiteralCompareValue* compareDataLitValue = dynamic_cast<CDataLiteralCompareValue*>(dataLitValue);
4687 if (compareDataLitValue) {
4688
4689 CDatatypeValueSpaceType* valueSpaceType = datatype->getValueSpaceType();
4690
4691 if (valueSpaceType) {
4692 CDatatypeValueSpaceCompareTriggers* compareValueSpaceConceptTrigger = (CDatatypeValueSpaceCompareTriggers*)valueSpacesTriggers->getValueSpaceTriggers(valueSpaceType);
4693
4694 if (compareValueSpaceConceptTrigger) {
4695 bool minRestriction = false;
4696 bool inclusive = false;
4697
4698 if (dataRestrictionCode == CDFC_MIN_EXCLUSIVE) {
4699 minRestriction = true;
4700 inclusive = false;
4701 } else if (dataRestrictionCode == CDFC_MIN_INCLUSIVE) {
4702 minRestriction = true;
4703 inclusive = true;
4704 } else if (dataRestrictionCode == CDFC_MAX_EXCLUSIVE) {
4705 minRestriction = false;
4706 inclusive = false;
4707 } else if (dataRestrictionCode == CDFC_MAX_INCLUSIVE) {
4708 minRestriction = false;
4709 inclusive = true;
4710 }
4711
4712 compareValueSpaceConceptTrigger->addMinMaxValueConceptTrigger(compareDataLitValue, minRestriction, inclusive, valueSpaceConceptTriggerLinker);
4713 }
4714 }
4715 }
4716
4717 }
4718 }
4719 }
4720 triggers = valueTrigger->append(triggers);
4721 }
4722 }
4723 }
4724
4725
4726 mConceptTriggerLinkerHash.insert(conNegPair,triggers);
4727 if (backPropTriggerConcept) {
4728 mBackPropActivationConHash.insert(conNegPair, backPropTriggerConcept);
4729 }
4730 }
4731 return triggers;
4732 }
4733
4734
4735
4736
4737 CDatatypeValueSpaceConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::createValueSpaceConceptTriggerLinker() {
4738 CDatatypeValueSpaceConceptTriggerLinker* valueSpaceConceptTriggerLinker = CObjectAllocator<CDatatypeValueSpaceConceptTriggerLinker>::allocateAndConstruct(mMemMan);
4739 return valueSpaceConceptTriggerLinker;
4740 }
4741
4742
4743
4744 bool CTriggeredImplicationBinaryAbsorberPreProcess::addAbsorbableDisjunctCandidates(CConcept* orConcept, bool negated, QList<TConceptNegationPair>& list) {
4745 bool absorbableDisjuncts = false;
4746 cint64 opCode = orConcept->getOperatorCode();
4747 if (!negated && opCode == CCOR || negated && (opCode == CCAND || opCode == CCEQ)) {
4748 CSortedNegLinker<CConcept*>* opConLinkerIt = orConcept->getOperandList();
4749 while (opConLinkerIt) {
4750 CConcept* opConcept = opConLinkerIt->getData();
4751 bool opNegated = opConLinkerIt->isNegated()^negated;
4752
4753 cint64 opOpCode = opConcept->getOperatorCode();
4754 if (!opNegated && opOpCode == CCOR || opNegated && (opOpCode == CCAND)) {
4755 absorbableDisjuncts |= addAbsorbableDisjunctCandidates(opConcept,opNegated,list);
4756 } else {
4757 list.append(TConceptNegationPair(opConcept,opNegated));
4758 absorbableDisjuncts = true;
4759 }
4760
4761 opConLinkerIt = opConLinkerIt->getNext();
4762 }
4763 }
4764 return absorbableDisjuncts;
4765 }
4766
4767 QList<CTriggeredImplicationBinaryAbsorberPreProcess::TConceptNegationPair> CTriggeredImplicationBinaryAbsorberPreProcess::splitAbsorbableDisjuncts(QList<TConceptNegationPair>& list) {
4768 QList<TConceptNegationPair> absorbableList;
4769 cint64 count = list.count();
4770 QHash<CConcept*,TOccuredAbsorbablePair> conceptEqConAbsorbed;
4771 for (cint64 nr = 0; nr < count; ++nr) {
4772 TConceptNegationPair conNegPair(list.takeFirst());
4773 CConcept* concept = conNegPair.first;
4774 bool negated = conNegPair.second;
4775 if (isConceptImplicationTriggerable(concept,!negated,&conceptEqConAbsorbed)) {
4776 absorbableList.append(conNegPair);
4777 } else {
4778 list.append(conNegPair);
4779 }
4780 }
4781 return absorbableList;
4782 }
4783
4784 QList<CTriggeredImplicationBinaryAbsorberPreProcess::TConceptNegationPair> CTriggeredImplicationBinaryAbsorberPreProcess::getPartialAbsorbableDisjuncts(QList<TConceptNegationPair>& list) {
4785 QList<TConceptNegationPair> absorbableList;
4786 cint64 count = list.count();
4787 QSet<CConcept*> conceptEqConAbsorbed;
4788 for (QList<TConceptNegationPair>::const_iterator it = list.constBegin(), itEnd = list.constEnd(); it != itEnd; ++it) {
4789 TConceptNegationPair conNegPair(*it);
4790 CConcept* concept = conNegPair.first;
4791 bool negated = conNegPair.second;
4792 if (isConceptPartialImplicationTriggerable(concept,!negated,&conceptEqConAbsorbed)) {
4793 absorbableList.append(conNegPair);
4794 }
4795 }
4796 return absorbableList;
4797 }
4798
4799
4800
4801
4802 QList<CTriggeredImplicationBinaryAbsorberPreProcess::TConceptNegationPair> CTriggeredImplicationBinaryAbsorberPreProcess::getAssuringAbsorbableDisjuncts(QList<TConceptNegationPair>& list) {
4803 QList<TConceptNegationPair> absorbableList;
4804 cint64 count = list.count();
4805 QSet<CConcept*> conceptEqConAbsorbed;
4806 for (QList<TConceptNegationPair>::const_iterator it = list.constBegin(), itEnd = list.constEnd(); it != itEnd; ++it) {
4807 TConceptNegationPair conNegPair(*it);
4808 CConcept* concept = conNegPair.first;
4809 bool negated = conNegPair.second;
4810 if (isConceptAssuringImplicationTriggerable(concept, !negated, &conceptEqConAbsorbed)) {
4811 absorbableList.append(conNegPair);
4812 }
4813 }
4814 return absorbableList;
4815 }
4816
4817
4818
4819
4820
4821 bool CTriggeredImplicationBinaryAbsorberPreProcess::isConceptAssuringImplicationTriggerable(CConcept* concept, bool negated, QSet<CConcept*>* conceptEqConAbsorbed) {
4822 TConceptNegationPair conNegPair(concept, negated);
4823 if (mConceptAssuringAbsorbableHash.contains(conNegPair)) {
4824 return mConceptAssuringAbsorbableHash.value(conNegPair);
4825 }
4826 cint64 opCode = concept->getOperatorCode();
4827 cint64 parm = concept->getParameter();
4828 cint64 opCount = concept->getOperandCount();
4829 CSortedNegLinker<CConcept*>* opConLinker = concept->getOperandList();
4830
4831 bool absorbable = false;
4832
4833 QHash<CConcept*, TOccuredAbsorbablePair> compConceptEqConAbsorbed;
4834 if (isConceptImplicationTriggerable(concept, negated, &compConceptEqConAbsorbed)) {
4835 absorbable = true;
4836 } else {
4837
4838
4839 if (!negated && (opCode == CCSOME || opCode == CCAQSOME) || negated && (opCode == CCALL)) {
4840 absorbable = true;
4841 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
4842 while (opConLinkerIt && absorbable) {
4843 CConcept* opConcept = opConLinkerIt->getData();
4844 bool opNegated = opConLinkerIt->isNegated() ^ negated;
4845 if (!isConceptAssuringImplicationTriggerable(opConcept, opNegated, conceptEqConAbsorbed)) {
4846 absorbable = false;
4847 }
4848 opConLinkerIt = opConLinkerIt->getNext();
4849 }
4850 } else if (!negated && (opCode == CCAND) || negated && opCode == CCOR) {
4851 // AND, at least one operand has to be triggerable
4852 if (opCount >= 1) {
4853 CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker;
4854 absorbable = true;
4855 while (opConLinkerIt && absorbable) {
4856 CConcept* opConcept = opConLinkerIt->getData();
4857 bool opNegated = opConLinkerIt->isNegated() ^ negated;
4858 if (!isConceptAssuringImplicationTriggerable(opConcept, opNegated, conceptEqConAbsorbed)) {
4859 absorbable = false;
4860 }
4861 opConLinkerIt = opConLinkerIt->getNext();
4862 }
4863 }
4864 } else if (!negated && (opCode == CCDATALITERAL)) {
4865 if (mConfDatatypeAbsorption) {
4866 CDataLiteral* dataLiteral = concept->getDataLiteral();
4867 if (dataLiteral) {
4868 CDataLiteralValue* dataLitValue = dataLiteral->getDataLiteralValue();
4869 if (dataLitValue) {
4870 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_REAL) {
4871 absorbable = true;
4872 }
4873 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_STRING) {
4874 absorbable = true;
4875 }
4876 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_BOOLEAN) {
4877 absorbable = true;
4878 }
4879 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_DOUBLE) {
4880 absorbable = true;
4881 }
4882 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_FLOAT) {
4883 absorbable = true;
4884 }
4885 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_IRI) {
4886 absorbable = true;
4887 }
4888 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_XML) {
4889 absorbable = true;
4890 }
4891 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_HEXBINARY) {
4892 absorbable = true;
4893 }
4894 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_BASE64BINARY) {
4895 absorbable = true;
4896 }
4897 if (dataLitValue->getDataValueType() == CDataLiteralValue::DLVT_DATETIME) {
4898 absorbable = true;
4899 }
4900 }
4901 }
4902 }
4903
4904
4905 } else {
4906 absorbable = false;
4907 }
4908 }
4909 mConceptAssuringAbsorbableHash.insert(conNegPair, absorbable);
4910 return absorbable;
4911 }
4912
4913
4914
4915
4916
4917
4918 CConceptTriggerLinker* CTriggeredImplicationBinaryAbsorberPreProcess::getAssuringTriggersForConcept(CConcept* concept, bool negated) {
4919 CConceptTriggerLinker* triggers = nullptr;
4920
4921 bool branchTiggerCreation = false;
4922 TConceptNegationPair conNegPair(concept, negated);
4923 triggers = mAssuringConceptTriggerLinkerHash.value(conNegPair);
4924 if (!triggers) {
4925
4926 cint64 opCode = concept->getOperatorCode();
4927 cint64 parm = concept->getParameter();
4928 cint64 opCount = concept->getOperandCount();
4929 CRole* role = concept->getRole();
4930 CSortedNegLinker<CConcept*>* opConLinker = concept->getOperandList();
4931
4932
4933 QHash<CConcept*, TOccuredAbsorbablePair> compConceptEqConAbsorbed;
4934 if (isConceptImplicationTriggerable(concept, negated, &compConceptEqConAbsorbed)) {
4935
4936 triggers = copyTriggerLinkers(getTriggersForConcept(concept, negated));
4937
4938
4939 } else if (!negated && (opCode == CCATOM || opCode == CCSUB || opCode == CCTOP || opCode == CCIMPLTRIG)) {
4940 CConceptTriggerLinker* newTrigger = createTriggerLinker();
4941 newTrigger->initConceptTriggerLinker(concept, 1);
4942 triggers = newTrigger->append(triggers);
4943
4944 } else if (!negated && (opCode == CCSOME) || negated && (opCode == CCALL)) {
4945 CConcept* propagatedTriggerConcept = nullptr;
4946 cint64 triggerComplexity = 1;
4947 bool negateOperands = negated && (opCode == CCSOME || opCode == CCSELF || opCode == CCALL);
4948 CConceptTriggerLinker* allTriggers = nullptr;
4949 for (CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
4950 CConcept* opConcept = opConLinkerIt->getData();
4951 bool opNegated = opConLinkerIt->isNegated() ^ negateOperands;
4952 CConceptTriggerLinker* newTrigger = copyTriggerLinkers(getAssuringTriggersForConcept(opConcept, opNegated));
4953 allTriggers = newTrigger->append(allTriggers);
4954 }
4955 if (allTriggers) {
4956 propagatedTriggerConcept = createTriggerConcept(branchTiggerCreation);
4957 CConcept* nextLevelTriggerConcept = createTriggerPropagationConcept(propagatedTriggerConcept, role, branchTiggerCreation);
4958 if (allTriggers->hasNext()) {
4959 // requires a generation of an implication concept
4960 CConceptTriggerLinker* implTriggeredConcept = getImplicationTriggeredConceptForTriggers(allTriggers, nullptr);
4961 triggerComplexity += implTriggeredConcept->getTriggerComplexity();
4962 addUnfoldingConceptForConcept(implTriggeredConcept->getTriggerConcept(), nextLevelTriggerConcept, false);
4963 } else {
4964 triggerComplexity += allTriggers->getTriggerComplexity();
4965 addUnfoldingConceptForConcept(allTriggers->getTriggerConcept(), nextLevelTriggerConcept, false);
4966 releaseTriggerLinkers(allTriggers);
4967 }
4968 } else {
4969 CRole* locatedRole = CConceptRoleIndividualLocator::getLocatedRole(role, mOnto);
4970 propagatedTriggerConcept = getRoleDomainTriggerConcept(locatedRole);
4971 }
4972 CConceptTriggerLinker* newTrigger = createTriggerLinker();
4973 newTrigger->initConceptTriggerLinker(propagatedTriggerConcept, triggerComplexity);
4974 triggers = newTrigger->append(triggers);
4975
4976
4977 } else if (negated && (opCode == CCOR) || !negated && (opCode == CCAND || opCode == CCEQ)) {
4978 // AND, collect triggers from operands
4979 CConceptTriggerLinker* andTriggers = nullptr;
4980 for (CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
4981 CConcept* opConcept = opConLinkerIt->getData();
4982 bool opNegated = opConLinkerIt->isNegated() ^ negated;
4983
4984 CConceptTriggerLinker* newTriggers = copyTriggerLinkers(getAssuringTriggersForConcept(opConcept, opNegated));
4985 andTriggers = newTriggers->append(andTriggers);
4986 }
4987 triggers = andTriggers->append(triggers);
4988
4989 } else if (!negated && (opCode == CCDATALITERAL)) {
4990 if (mConfDatatypeAbsorption) {
4991 CDataLiteral* dataLiteral = concept->getDataLiteral();
4992 if (dataLiteral) {
4993 CDataLiteralValue* dataLitValue = dataLiteral->getDataLiteralValue();
4994 if (dataLitValue) {
4995
4996 cint64 triggerComplexity = 2;
4997 CConcept* valueTriggerConcept = createTriggerConcept(branchTiggerCreation);
4998 CConceptTriggerLinker* valueTrigger = createTriggerLinker();
4999 valueTrigger->initConceptTriggerLinker(valueTriggerConcept, triggerComplexity);
5000 CDatatypeValueSpaceConceptTriggerLinker* valueSpaceConceptTriggerLinker = createValueSpaceConceptTriggerLinker();
5001 valueSpaceConceptTriggerLinker->initConceptTrigger(valueTriggerConcept);
5002
5003
5004 CDatatypeValueSpaceTriggers* valueSpaceTrigger = nullptr;
5005 CDataLiteralValue* dataLitValue = dataLiteral->getDataLiteralValue();
5006 if (dataLitValue) {
5007 CDataLiteralCompareValue* compareDataLitValue = dynamic_cast<CDataLiteralCompareValue*>(dataLitValue);
5008 if (compareDataLitValue) {
5009 CDatatypeValueSpaceType* valueSpaceType = nullptr;
5010 CDataLiteralValue::DATA_LITERAL_VALUE_TYPE dataLiteralValueType = compareDataLitValue->getDataValueType();
5011 CDatatypeValueSpaceTypes* valueSpaceTypes = CDatatypeValueSpaceTypes::getValueSpaceTypes();
5012 if (dataLiteralValueType == CDataLiteralValue::DLVT_REAL) {
5013 valueSpaceType = valueSpaceTypes->getValueSpaceRealType();
5014 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_STRING) {
5015 valueSpaceType = valueSpaceTypes->getValueSpaceStringType();
5016 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_BOOLEAN) {
5017 valueSpaceType = valueSpaceTypes->getValueSpaceBooleanType();
5018 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_DOUBLE) {
5019 valueSpaceType = valueSpaceTypes->getValueSpaceDoubleType();
5020 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_FLOAT) {
5021 valueSpaceType = valueSpaceTypes->getValueSpaceFloatType();
5022 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_IRI) {
5023 valueSpaceType = valueSpaceTypes->getValueSpaceIRIType();
5024 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_XML) {
5025 valueSpaceType = valueSpaceTypes->getValueSpaceXMLType();
5026 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_HEXBINARY) {
5027 valueSpaceType = valueSpaceTypes->getValueSpaceBinaryHexDataType();
5028 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_BASE64BINARY) {
5029 valueSpaceType = valueSpaceTypes->getValueSpaceBinaryBase64DataType();
5030 } else if (dataLiteralValueType == CDataLiteralValue::DLVT_DATETIME) {
5031 valueSpaceType = valueSpaceTypes->getValueSpaceDateTimeType();
5032 }
5033
5034 if (valueSpaceType) {
5035 CDatatypeValueSpacesTriggers* valueSpacesTriggers = mMBox->getValueSpacesTriggers(true);
5036 CDatatypeValueSpaceCompareTriggers* compareValueSpaceConceptTrigger = (CDatatypeValueSpaceCompareTriggers*)valueSpacesTriggers->getValueSpaceTriggers(valueSpaceType);
5037 if (compareValueSpaceConceptTrigger) {
5038 compareValueSpaceConceptTrigger->addCompleteValueConceptTrigger(compareDataLitValue, valueSpaceConceptTriggerLinker);
5039 }
5040 }
5041 }
5042 }
5043
5044 triggers = valueTrigger->append(triggers);
5045
5046 }
5047 }
5048 }
5049 }
5050
5051 mAssuringConceptTriggerLinkerHash.insert(conNegPair, triggers);
5052 }
5053 return triggers;
5054 }
5055
5056
5057 }; // end namespace Preprocess
5058
5059 }; // end namespace Reasoner
5060
5061 }; // end namespace Konclude