Debian Codegraph @

Source/Reasoner/Preprocess/CNominalSchemaTemplateExtractionPreProcess.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 "CNominalSchemaTemplateExtractionPreProcess.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Preprocess {
29
30
31
32 CNominalSchemaTemplateExtractionPreProcess::CNominalSchemaTemplateExtractionPreProcess() {
33 }
34
35
36 CNominalSchemaTemplateExtractionPreProcess::~CNominalSchemaTemplateExtractionPreProcess() {
37 }
38
39
40 CConcreteOntology *CNominalSchemaTemplateExtractionPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) {
41
42 bool nominalSchemaConstructsUsed = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getBuildConstructFlags()->isNominalSchemaUsed();
43 if (nominalSchemaConstructsUsed) {
44
45 mStatCreatedTemplateCount = 0;
46 mStatReplacedConceptCount = 0;
47 mNomSchTemplVec = nullptr;
48
49 mTBox = ontology->getDataBoxes()->getTBox();
50 CRBox *rBox = ontology->getDataBoxes()->getRBox();
51 CABox *aBox = ontology->getDataBoxes()->getABox();
52 mMBox = ontology->getDataBoxes()->getMBox();
53
54 mConceptVec = mTBox->getConceptVector();
55 mConceptCount = mConceptVec->getItemCount();
56
57 mRolesVec = rBox->getRoleVector();
58 mRoleCount = mRolesVec->getItemCount();
59
60 mTopConcept = mTBox->getTopConcept();
61 mBottomConcept = mTBox->getBottomConcept();
62
63 mMemMan = ontology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager();
64 mOnto = ontology;
65
66 mIndividualVector = aBox->getIndividualVector(false);
67 mIndividualCount = 0;
68 if (mIndividualVector) {
69 mIndividualCount = mIndividualVector->getItemCount();
70 }
71
72 bool nominalSchemaConcepts = false;
73 for (cint64 i = 0; !nominalSchemaConcepts && i < mConceptCount; ++i) {
74 CConcept* concept = mConceptVec->getData(i);
75 if (concept) {
76 cint64 conOpCode = concept->getOperatorCode();
77 if (conOpCode == CCNOMVAR) {
78 nominalSchemaConcepts = true;
79 }
80 }
81 }
82
83
84 if (nominalSchemaConcepts) {
85 for (cint64 i = 0; i < mConceptCount; ++i) {
86 CConcept* concept = mConceptVec->getLocalData(i);
87 if (concept) {
88 cint64 conOpCode = concept->getOperatorCode();
89 if (conOpCode == CCEQ) {
90
91 bool foundNominalSchemaConcept = false;
92 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt && !foundNominalSchemaConcept; opConLinkerIt = opConLinkerIt->getNext()) {
93 CConcept* opConcept = opConLinkerIt->getData();
94 bool opConNegation = opConLinkerIt->isNegated();
95
96 foundNominalSchemaConcept = hasNominalSchemaConcept(opConcept);
97 }
98
99 if (foundNominalSchemaConcept) {
100 transformEquivalentConceptToGCI(concept);
101 }
102 }
103 }
104 }
105
106 for (cint64 i = 0; i < mConceptCount; ++i) {
107 CConcept* concept = mConceptVec->getLocalData(i);
108 if (concept) {
109 cint64 conOpCode = concept->getOperatorCode();
110 if (conOpCode == CCSUB) {
111
112 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
113 CConcept* opConcept = opConLinkerIt->getData();
114 bool opConNegation = opConLinkerIt->isNegated();
115
116 if (hasNominalSchemaConcept(opConcept)) {
117 ++mStatReplacedConceptCount;
118 CNominalSchemaTemplate* nomSchTempl = getNominalSchemaTemplate(opConcept,opConNegation);
119 CConcept* templRefConcept = nomSchTempl->getReferenceConcept();
120 opConLinkerIt->setData(templRefConcept);
121 }
122 }
123
124 }
125 }
126 }
127
128
129 for (cint64 i = 0; i < mRoleCount; ++i) {
130 CRole* role = mRolesVec->getLocalData(i);
131 if (role) {
132 for (CSortedNegLinker<CConcept*>* domConLinkerIt = role->getDomainConceptList(); domConLinkerIt; domConLinkerIt = domConLinkerIt->getNext()) {
133 CConcept* opConcept = domConLinkerIt->getData();
134 bool opConNegation = domConLinkerIt->isNegated();
135
136 if (hasNominalSchemaConcept(opConcept)) {
137 ++mStatReplacedConceptCount;
138 CNominalSchemaTemplate* nomSchTempl = getNominalSchemaTemplate(opConcept,opConNegation);
139 CConcept* templRefConcept = nomSchTempl->getReferenceConcept();
140 domConLinkerIt->setData(templRefConcept);
141 }
142 }
143 for (CSortedNegLinker<CConcept*>* rangConLinkerIt = role->getRangeConceptList(); rangConLinkerIt; rangConLinkerIt = rangConLinkerIt->getNext()) {
144 CConcept* opConcept = rangConLinkerIt->getData();
145 bool opConNegation = rangConLinkerIt->isNegated();
146
147 if (hasNominalSchemaConcept(opConcept)) {
148 ++mStatReplacedConceptCount;
149 CNominalSchemaTemplate* nomSchTempl = getNominalSchemaTemplate(opConcept,opConNegation);
150 CConcept* templRefConcept = nomSchTempl->getReferenceConcept();
151 rangConLinkerIt->setData(templRefConcept);
152 }
153 }
154
155 }
156 }
157
158 for (CSortedNegLinker<CConcept*>* gciConLinkerIt = mTopConcept->getOperandList(); gciConLinkerIt; gciConLinkerIt = gciConLinkerIt->getNext()) {
159 CConcept* opConcept = gciConLinkerIt->getData();
160 bool opConNegation = gciConLinkerIt->isNegated();
161
162 if (hasNominalSchemaConcept(opConcept)) {
163 if (!removeSingleAbsorbableNominalSchemaConcepts(opConcept,opConNegation)) {
164 ++mStatReplacedConceptCount;
165 CNominalSchemaTemplate* nomSchTempl = getNominalSchemaTemplate(opConcept,opConNegation);
166 CConcept* templRefConcept = nomSchTempl->getReferenceConcept();
167 gciConLinkerIt->setData(templRefConcept);
168 }
169 }
170 }
171
172
173 if (mIndividualVector) {
174 for (cint64 i = 0; i < mIndividualCount; ++i) {
175 CIndividual* individual = mIndividualVector->getLocalData(i);
176 if (individual) {
177
178 for (CConceptAssertionLinker* assConLinkerIt = individual->getAssertionConceptLinker(); assConLinkerIt; assConLinkerIt = assConLinkerIt->getNext()) {
179 CConcept* assCon = assConLinkerIt->getData();
180 bool assConNegation = assConLinkerIt->isNegated();
181 if (hasNominalSchemaConcept(assCon)) {
182 ++mStatReplacedConceptCount;
183 CNominalSchemaTemplate* nomSchTempl = getNominalSchemaTemplate(assCon,assConNegation);
184 CConcept* templRefConcept = nomSchTempl->getReferenceConcept();
185 assConLinkerIt->setData(templRefConcept);
186 }
187 }
188
189 }
190 }
191 }
192 }
193
194 LOG(INFO,"::Konclude::Reasoner::Preprocess::NominalSchemaTemplateExtractor",logTr("Extracted %1 nominal schema templates, replaced %2 concepts.").arg(mStatCreatedTemplateCount).arg(mStatReplacedConceptCount),this);
195
196 }
197 return ontology;
198 }
199
200
201
202
203 bool CNominalSchemaTemplateExtractionPreProcess::removeSingleAbsorbableNominalSchemaConcepts(CConcept* concept, bool negation) {
204 bool allRemoved = true;
205 QHash<CConcept*,cint64> nominalSchemaConceptCountHash;
206 countNominalSchemaConcepts(concept,&nominalSchemaConceptCountHash);
207 QSet<CConcept*> absorbableNominalVariableSet;
208 if (findAbsorbableNominalSchemas(concept,negation,&absorbableNominalVariableSet)) {
209 QSet<CConcept*> removeNominalVariableSet;
210 for (QHash<CConcept*,cint64>::const_iterator it = nominalSchemaConceptCountHash.constBegin(), itEnd = nominalSchemaConceptCountHash.constEnd(); it != itEnd; ++it) {
211 cint64 nomSchCount = it.value();
212 CConcept* concept = it.key();
213 if (nomSchCount <= 1 && absorbableNominalVariableSet.contains(concept)) {
214 removeNominalVariableSet.insert(concept);
215 } else {
216 allRemoved = false;
217 }
218 }
219 if (!removeNominalVariableSet.isEmpty()) {
220 CConcept* replaceConcept = mTBox->getIndividualTriggerConcept();
221 replaceNominalSchemasConcepts(concept,replaceConcept,removeNominalVariableSet);
222 }
223 } else {
224 allRemoved = false;
225 }
226 return allRemoved;
227 }
228
229
230 void CNominalSchemaTemplateExtractionPreProcess::replaceNominalSchemasConcepts(CConcept* concept, CConcept* replacingConcept, const QSet<CConcept*>& removeNominalVariableSet) {
231 cint64 conOpCode = concept->getOperatorCode();
232 if ((conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM)) {
233 } else {
234 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
235 CConcept* opConcept = opConLinkerIt->getData();
236 if (removeNominalVariableSet.contains(opConcept)) {
237 opConLinkerIt->setData(replacingConcept);
238 } else {
239 replaceNominalSchemasConcepts(opConcept,replacingConcept,removeNominalVariableSet);
240 }
241 }
242 }
243 }
244
245
246 void CNominalSchemaTemplateExtractionPreProcess::countNominalSchemaConcepts(CConcept* concept, QHash<CConcept*,cint64>* nominalSchemaConceptCountHash) {
247 cint64 conOpCode = concept->getOperatorCode();
248 if ((conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM)) {
249 } else if (conOpCode == CCNOMVAR) {
250 cint64 prevCount = nominalSchemaConceptCountHash->value(concept,0);
251 nominalSchemaConceptCountHash->insert(concept,prevCount+1);
252 } else {
253 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
254 CConcept* opConcept = opConLinkerIt->getData();
255 countNominalSchemaConcepts(opConcept,nominalSchemaConceptCountHash);
256 }
257 }
258 }
259
260
261
262 bool CNominalSchemaTemplateExtractionPreProcess::findAbsorbableNominalSchemas(CConcept* concept, bool negation, QSet<CConcept*>* absorbableNominalVariableSet) {
263 cint64 opCode = concept->getOperatorCode();
264 cint64 param = concept->getParameter();
265 if (negation && (opCode == CCSOME) || !negation && (opCode == CCALL || opCode == CCSOME)) {
266 bool oneAbsorbable = false;
267 for (CSortedNegLinker<CConcept*>* opLinkerIt = concept->getOperandList(); opLinkerIt; opLinkerIt = opLinkerIt->getNext()) {
268 CConcept* opConcept = opLinkerIt->getData();
269 bool opConNegation = opLinkerIt->isNegated() ^ negation;
270 oneAbsorbable |= findAbsorbableNominalSchemas(opConcept,opConNegation,absorbableNominalVariableSet);
271 }
272 return oneAbsorbable;
273 } else if (negation && (opCode == CCOR || opCode == CCAND) || !negation && (opCode == CCAND || opCode == CCOR)) {
274 bool oneAbsorbable = true;
275 for (CSortedNegLinker<CConcept*>* opLinkerIt = concept->getOperandList(); opLinkerIt; opLinkerIt = opLinkerIt->getNext()) {
276 CConcept* opConcept = opLinkerIt->getData();
277 bool opConNegation = opLinkerIt->isNegated() ^ negation;
278 oneAbsorbable |= findAbsorbableNominalSchemas(opConcept,opConNegation,absorbableNominalVariableSet);
279 }
280 return oneAbsorbable;
281 } else if (negation && (opCode == CCNOMVAR)) {
282 absorbableNominalVariableSet->insert(concept);
283 return true;
284 }
285 return false;
286 }
287
288
289
290 void CNominalSchemaTemplateExtractionPreProcess::addConceptOperand(CConcept* concept, CConcept* opConcept, bool negated) {
291 CSortedNegLinker<CConcept*>* opConLinker = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
292 opConLinker->init(opConcept,negated);
293 concept->addOperandLinker(opConLinker);
294 concept->incOperandCount();
295 }
296
297
298 CConcept* CNominalSchemaTemplateExtractionPreProcess::transformEquivalentConceptToGCI(CConcept* eqConcept) {
299 eqConcept->setOperatorCode(CCSUB);
300 CConcept* concept = createNewConcept();
301 concept->setOperatorCode(CCOR);
302 mConceptVec->setData(concept->getConceptTag(),concept);
303 addConceptOperand(eqConcept,concept,false);
304 for (CSortedNegLinker<CConcept*>* opConLinkerIt = eqConcept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
305 CConcept* opConcept = opConLinkerIt->getData();
306 bool opConNegation = opConLinkerIt->isNegated();
307 addConceptOperand(eqConcept,opConcept,!opConNegation);
308 }
309 mTopConcept = CConceptRoleIndividualLocator::getLocatedConcept(mTopConcept,mOnto);
310 addConceptOperand(mTopConcept,concept,false);
311 return concept;
312 }
313
314 CConcept* CNominalSchemaTemplateExtractionPreProcess::createNewConcept() {
315 CConcept* concept = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan);
316 concept->initConcept();
317 cint64 nextConTag = mTBox->getNextConceptID();
318 concept->initTag(nextConTag);
319 return concept;
320 }
321
322
323 CConcept* CNominalSchemaTemplateExtractionPreProcess::createNominalSchemaTemplateReferenceConcept(CNominalSchemaTemplate* nsTemplate) {
324 CConcept* concept = createNewConcept();
325 concept->setOperatorCode(CCNOMTEMPLREF);
326 concept->setParameter(nsTemplate->getNominalSchemaTemplateTag());
327 mConceptVec->setData(concept->getConceptTag(),concept);
328 nsTemplate->setReferenceConcept(concept);
329 return concept;
330 }
331
332
333 CNominalSchemaTemplate* CNominalSchemaTemplateExtractionPreProcess::getNominalSchemaTemplate(CConcept* concept, bool negation) {
334 CNominalSchemaTemplate* nsTemplate = mConceptNominalSchemaTemplateHash.value(concept);
335 if (!nsTemplate) {
336 ++mStatCreatedTemplateCount;
337
338 nsTemplate = CObjectAllocator< CNominalSchemaTemplate >::allocateAndConstruct(mMemMan);
339 CBOXSET<CConcept*>* nominalSchemaConceptSet = CObjectAllocator< CBOXSET<CConcept*> >::allocateAndConstruct(mMemMan);
340 CBOXHASH<CConcept*,CConcept*>* conceptNominalSchemaConceptHash = CObjectAllocator< CBOXHASH<CConcept*,CConcept*> >::allocateAndConstruct(mMemMan);
341 CBOXHASH<CConcept*,CConcept*>* absorbableConceptNominalSchemaConceptHash = CObjectAllocator< CBOXHASH<CConcept*,CConcept*> >::allocateAndConstruct(mMemMan);
342 nsTemplate->initNominalSchemaTemplate(nominalSchemaConceptSet,conceptNominalSchemaConceptHash,absorbableConceptNominalSchemaConceptHash);
343 if (!mNomSchTemplVec) {
344 mNomSchTemplVec = mMBox->getNominalSchemaTemplateVector();
345 }
346 cint64 nextNomSchTemplID = mNomSchTemplVec->getItemCount();
347 nsTemplate->setNominalSchemaTemplateTag(nextNomSchTemplID);
348 mNomSchTemplVec->setData(nextNomSchTemplID,nsTemplate);
349 nsTemplate->setTemplateConcept(concept);
350 collectNominalSchemaConcepts(concept,nominalSchemaConceptSet);
351 createNominalSchemaTemplateReferenceConcept(nsTemplate);
352
353 FOREACHIT (CConcept* nomSchConcept, *nominalSchemaConceptSet) {
354 QSet<CConcept*> testedNomSchemConSet;
355 hasNominalSchemaConceptFillHash(concept,conceptNominalSchemaConceptHash,nomSchConcept,&testedNomSchemConSet);
356 QSet<CConcept*> testedNomSchemAbsorbedConSet;
357 hasNominalSchemaAbsorbableConceptFillHash(concept,negation,absorbableConceptNominalSchemaConceptHash,nomSchConcept,&testedNomSchemAbsorbedConSet);
358 }
359
360 mConceptNominalSchemaTemplateHash.insert(concept,nsTemplate);
361 }
362 return nsTemplate;
363 }
364
365
366 bool CNominalSchemaTemplateExtractionPreProcess::hasNominalSchemaAbsorbableConceptFillHash(CConcept* concept, bool negation, CBOXHASH<CConcept*,CConcept*>* absorbableConceptNominalSchemaConceptHash, CConcept* nominalSchemaConcept, QSet<CConcept*>* testedConceptSet) {
367 cint64 conOpCode = concept->getOperatorCode();
368 if ((conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM)) {
369 return false;
370 }
371 bool foundAbsorbableNominalSchemaConcept = false;
372
373 if (negation && concept == nominalSchemaConcept) {
374 foundAbsorbableNominalSchemaConcept = true;
375 } else {
376 cint64 conCode = concept->getOperatorCode();
377 if (negation && (conCode == CCSOME) || !negation && (conCode == CCALL)) {
378 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
379 CConcept* opConcept = opConLinkerIt->getData();
380 foundAbsorbableNominalSchemaConcept |= hasNominalSchemaAbsorbableConceptFillHash(opConcept,negation^opConLinkerIt->isNegated(),absorbableConceptNominalSchemaConceptHash,nominalSchemaConcept,testedConceptSet);
381 }
382 } else if (!negation && (conCode == CCAND || conCode == CCOR) || negation && (conCode == CCOR || conCode == CCAND)) {
383 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
384 CConcept* opConcept = opConLinkerIt->getData();
385 foundAbsorbableNominalSchemaConcept |= hasNominalSchemaAbsorbableConceptFillHash(opConcept,negation^opConLinkerIt->isNegated(),absorbableConceptNominalSchemaConceptHash,nominalSchemaConcept,testedConceptSet);
386 }
387 }
388 }
389
390 if (foundAbsorbableNominalSchemaConcept) {
391 if (!testedConceptSet->contains(concept)) {
392 testedConceptSet->insert(concept);
393 absorbableConceptNominalSchemaConceptHash->insertMulti(concept,nominalSchemaConcept);
394 }
395 }
396 return foundAbsorbableNominalSchemaConcept;
397 }
398
399
400 bool CNominalSchemaTemplateExtractionPreProcess::hasNominalSchemaConceptFillHash(CConcept* concept, CBOXHASH<CConcept*,CConcept*>* conceptNominalSchemaConceptHash, CConcept* nominalSchemaConcept, QSet<CConcept*>* testedConceptSet) {
401 cint64 conOpCode = concept->getOperatorCode();
402 if ((conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM)) {
403 return false;
404 }
405 bool foundNominalSchemaConcept = false;
406
407 if (concept == nominalSchemaConcept) {
408 foundNominalSchemaConcept = true;
409 } else {
410 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
411 CConcept* opConcept = opConLinkerIt->getData();
412 foundNominalSchemaConcept |= hasNominalSchemaConceptFillHash(opConcept,conceptNominalSchemaConceptHash,nominalSchemaConcept,testedConceptSet);
413 }
414 }
415
416 if (foundNominalSchemaConcept) {
417 if (!testedConceptSet->contains(concept)) {
418 testedConceptSet->insert(concept);
419 conceptNominalSchemaConceptHash->insertMulti(concept,nominalSchemaConcept);
420 }
421 }
422 return foundNominalSchemaConcept;
423 }
424
425
426 void CNominalSchemaTemplateExtractionPreProcess::collectNominalSchemaConcepts(CConcept* concept, CBOXSET<CConcept*>* nominalSchemaConceptSet) {
427 cint64 conOpCode = concept->getOperatorCode();
428 if ((conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM)) {
429 } else if (conOpCode == CCNOMVAR) {
430 nominalSchemaConceptSet->insert(concept);
431 } else {
432 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
433 CConcept* opConcept = opConLinkerIt->getData();
434 collectNominalSchemaConcepts(opConcept,nominalSchemaConceptSet);
435 }
436 }
437 }
438
439
440 bool CNominalSchemaTemplateExtractionPreProcess::hasNominalSchemaConcept(CConcept* concept) {
441 cint64 conOpCode = concept->getOperatorCode();
442 if ((conOpCode == CCSUB || conOpCode == CCEQ || conOpCode == CCTOP || conOpCode == CCBOTTOM)) {
443 return false;
444 } else if (conOpCode == CCNOMVAR) {
445 return true;
446 }
447
448 if (mConceptNominalSchemaHash.contains(concept)) {
449 return mConceptNominalSchemaHash.value(concept);
450 }
451
452 bool foundNominalSchemaConcept = false;
453 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt && !foundNominalSchemaConcept; opConLinkerIt = opConLinkerIt->getNext()) {
454 CConcept* opConcept = opConLinkerIt->getData();
455 foundNominalSchemaConcept = hasNominalSchemaConcept(opConcept);
456 }
457
458 mConceptNominalSchemaHash.insert(concept,foundNominalSchemaConcept);
459 return foundNominalSchemaConcept;
460 }
461
462 }; // end namespace Preprocess
463
464 }; // end namespace Reasoner
465
466 }; // end namespace Konclude