Debian Codegraph @

Source/Reasoner/Preprocess/CFullNominalSchemaGroundingPreProcess.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 "CFullNominalSchemaGroundingPreProcess.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Preprocess {
29
30
31
32 CFullNominalSchemaGroundingPreProcess::CFullNominalSchemaGroundingPreProcess() {
33 mConfReuseGroundedNominalSchemaConcepts = true;
34 mConfGroundNominalSchemaAbsorbableConcepts = false;
35 mConfFullyGroundNominalSchemaConcepts = false;
36 }
37
38
39 CFullNominalSchemaGroundingPreProcess::~CFullNominalSchemaGroundingPreProcess() {
40 }
41
42
43 CConcreteOntology *CFullNominalSchemaGroundingPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) {
44
45 bool nominalSchemaConstructsUsed = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getBuildConstructFlags()->isNominalSchemaUsed();
46
47 if (nominalSchemaConstructsUsed) {
48 mStatReplacedConceptCount = 0;
49 mStatCreatedConceptCount = 0;
50 mStatGroundedTemplateCount = 0;
51 mStatInstantiatedAxiomsCount = 0;
52
53 mTBox = ontology->getDataBoxes()->getTBox();
54 CRBox *rBox = ontology->getDataBoxes()->getRBox();
55 CABox *aBox = ontology->getDataBoxes()->getABox();
56 mMBox = ontology->getDataBoxes()->getMBox();
57
58 CConfiguration* config = context->getConfiguration();
59 mConfGroundNominalSchemaAbsorbableConcepts = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.AbsorbableNominalSchemaGrounding",false);
60 mConfFullyGroundNominalSchemaConcepts = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Preprocessing.FullNominalSchemaGrounding",false);
61 mConfGroundNominalSchemaAbsorbableConcepts |= mConfFullyGroundNominalSchemaConcepts;
62
63 mConceptVec = mTBox->getConceptVector();
64 mConceptCount = mConceptVec->getItemCount();
65
66 mRolesVec = rBox->getRoleVector();
67 mRoleCount = mRolesVec->getItemCount();
68
69 mTopConcept = mTBox->getTopConcept();
70 mBottomConcept = mTBox->getBottomConcept();
71
72 mMemMan = ontology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager();
73 mOnto = ontology;
74
75 mNomSchTemplVec = mMBox->getNominalSchemaTemplateVector(false);
76
77 mIndividualVector = aBox->getIndividualVector(false);
78 mIndividualCount = 0;
79 if (mIndividualVector) {
80 mIndividualCount = mIndividualVector->getItemCount();
81 // TODO: only active individuals
82 for (cint64 i = 0; i < mIndividualCount; ++i) {
83 CIndividual* individual = mIndividualVector->getData(i);
84 if (individual) {
85 for (CConceptAssertionLinker* assConLinkerIt = individual->getAssertionConceptLinker(); assConLinkerIt; assConLinkerIt = assConLinkerIt->getNext()) {
86 CConcept* assCon = assConLinkerIt->getData();
87 bool assConNegation = assConLinkerIt->isNegated();
88 cint64 assConOpCode = assCon->getOperatorCode();
89 if (!assConNegation && assConOpCode == CCNOMINAL) {
90 mNominalConceptSet.insert(assCon);
91 }
92 }
93 }
94 }
95 }
96
97 if (mNomSchTemplVec) {
98 for (cint64 i = 0; i < mConceptCount; ++i) {
99 CConcept* concept = mConceptVec->getLocalData(i);
100 if (concept) {
101 cint64 conOpCode = concept->getOperatorCode();
102 if (conOpCode == CCSUB) {
103
104 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
105 CConcept* opConcept = opConLinkerIt->getData();
106 bool opConNegation = opConLinkerIt->isNegated();
107
108 cint64 opConOpCode = opConcept->getOperatorCode();
109 if (opConOpCode == CCNOMTEMPLREF) {
110 cint64 templNumber = opConcept->getParameter();
111 CNominalSchemaTemplate* nsTemplate = mNomSchTemplVec->getData(templNumber);
112 if (nsTemplate) {
113 CConcept* nomSchAxiomCollConcept = createNominalSchemaAxiomCollectionConcept(opConcept,opConNegation,nsTemplate);
114 opConLinkerIt->setData(nomSchAxiomCollConcept);
115 opConLinkerIt->setNegated(false);
116 }
117 }
118 }
119
120 }
121 }
122 }
123
124
125 for (cint64 i = 0; i < mRoleCount; ++i) {
126 CRole* role = mRolesVec->getLocalData(i);
127 if (role) {
128 for (CSortedNegLinker<CConcept*>* domConLinkerIt = role->getDomainConceptList(); domConLinkerIt; domConLinkerIt = domConLinkerIt->getNext()) {
129 CConcept* opConcept = domConLinkerIt->getData();
130 bool opConNegation = domConLinkerIt->isNegated();
131
132 cint64 opConOpCode = opConcept->getOperatorCode();
133 if (opConOpCode == CCNOMTEMPLREF) {
134 cint64 templNumber = opConcept->getParameter();
135 CNominalSchemaTemplate* nsTemplate = mNomSchTemplVec->getData(templNumber);
136 if (nsTemplate) {
137 CConcept* nomSchAxiomCollConcept = createNominalSchemaAxiomCollectionConcept(opConcept,opConNegation,nsTemplate);
138 domConLinkerIt->setData(nomSchAxiomCollConcept);
139 domConLinkerIt->setNegated(false);
140 }
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 cint64 opConOpCode = opConcept->getOperatorCode();
148 if (opConOpCode == CCNOMTEMPLREF) {
149 cint64 templNumber = opConcept->getParameter();
150 CNominalSchemaTemplate* nsTemplate = mNomSchTemplVec->getData(templNumber);
151 if (nsTemplate) {
152 CConcept* nomSchAxiomCollConcept = createNominalSchemaAxiomCollectionConcept(opConcept,opConNegation,nsTemplate);
153 rangConLinkerIt->setData(nomSchAxiomCollConcept);
154 rangConLinkerIt->setNegated(false);
155 }
156 }
157 }
158 }
159 }
160
161
162 for (CSortedNegLinker<CConcept*>* gciConLinkerIt = mTopConcept->getOperandList(); gciConLinkerIt; gciConLinkerIt = gciConLinkerIt->getNext()) {
163 CConcept* opConcept = gciConLinkerIt->getData();
164 bool opConNegation = gciConLinkerIt->isNegated();
165
166 cint64 opConOpCode = opConcept->getOperatorCode();
167 if (opConOpCode == CCNOMTEMPLREF) {
168 cint64 templNumber = opConcept->getParameter();
169 CNominalSchemaTemplate* nsTemplate = mNomSchTemplVec->getData(templNumber);
170 if (nsTemplate && requiresGCIGrounding(nsTemplate,opConNegation)) {
171 CConcept* nomSchAxiomCollConcept = createNominalSchemaAxiomCollectionConcept(opConcept,opConNegation,nsTemplate);
172 gciConLinkerIt->setData(nomSchAxiomCollConcept);
173 gciConLinkerIt->setNegated(false);
174 }
175 }
176 }
177
178
179 if (mIndividualVector) {
180 for (cint64 i = 0; i < mIndividualCount; ++i) {
181 CIndividual* individual = mIndividualVector->getLocalData(i);
182 if (individual) {
183
184 for (CConceptAssertionLinker* assConLinkerIt = individual->getAssertionConceptLinker(); assConLinkerIt; assConLinkerIt = assConLinkerIt->getNext()) {
185 CConcept* assCon = assConLinkerIt->getData();
186 bool assConNegation = assConLinkerIt->isNegated();
187
188 cint64 opConOpCode = assCon->getOperatorCode();
189 if (opConOpCode == CCNOMTEMPLREF) {
190 cint64 templNumber = assCon->getParameter();
191 CNominalSchemaTemplate* nsTemplate = mNomSchTemplVec->getData(templNumber);
192 if (nsTemplate) {
193 CConcept* nomSchAxiomCollConcept = createNominalSchemaAxiomCollectionConcept(assCon,assConNegation,nsTemplate);
194 assConLinkerIt->setData(nomSchAxiomCollConcept);
195 assConLinkerIt->setNegation(false);
196 }
197 }
198 }
199
200 }
201 }
202 }
203
204
205 }
206
207 LOG(INFO,"::Konclude::Reasoner::Preprocess::FullNominalSchemaGrounder",logTr("Grounded %1 nominal schema templates, added %2 axioms with %3 created concepts.").arg(mStatGroundedTemplateCount).arg(mStatInstantiatedAxiomsCount).arg(mStatCreatedConceptCount),this);
208 }
209 return ontology;
210 }
211
212
213 bool CFullNominalSchemaGroundingPreProcess::requiresGCIGrounding(CNominalSchemaTemplate* nsTemplate, bool negated) {
214 CConcept* templConcept = nsTemplate->getTemplateConcept();
215
216 if (mReqGroundConHash.contains(QPair<CConcept*,bool>(templConcept,negated))) {
217 return mReqGroundConHash.value(QPair<CConcept*,bool>(templConcept,negated));
218 }
219
220 bool requiresGrounding = true;
221
222 if (!mConfGroundNominalSchemaAbsorbableConcepts) {
223 cint64 opCode = templConcept->getOperatorCode();
224 if (!negated && opCode == CCOR || negated && opCode == CCAND) {
225 QSet<CConcept*> absorbableNominalVariableSet;
226 for (CSortedNegLinker<CConcept*>* opLinkerIt = templConcept->getOperandList(); opLinkerIt; opLinkerIt = opLinkerIt->getNext()) {
227 CConcept* opConcept = opLinkerIt->getData();
228 bool opConNegation = opLinkerIt->isNegated() ^ negated;
229 findAbsorbableNominalSchemas(opConcept,opConNegation,&absorbableNominalVariableSet);
230 }
231 bool absorbable = absorbableNominalVariableSet.count() > 0;
232 requiresGrounding = !absorbable;
233 }
234 }
235
236 mReqGroundConHash.insert(QPair<CConcept*,bool>(templConcept,negated),requiresGrounding);
237 return requiresGrounding;
238 }
239
240 bool CFullNominalSchemaGroundingPreProcess::findAbsorbableNominalSchemas(CConcept* concept, bool negation, QSet<CConcept*>* absorbableNominalVariableSet) {
241 cint64 opCode = concept->getOperatorCode();
242 cint64 param = concept->getParameter();
243 if (negation && (opCode == CCSOME || opCode == CCAND) || !negation && (opCode == CCALL || opCode == CCSOME)) {
244 bool oneAbsorbable = false;
245 for (CSortedNegLinker<CConcept*>* opLinkerIt = concept->getOperandList(); opLinkerIt; opLinkerIt = opLinkerIt->getNext()) {
246 CConcept* opConcept = opLinkerIt->getData();
247 bool opConNegation = opLinkerIt->isNegated() ^ negation;
248 oneAbsorbable |= findAbsorbableNominalSchemas(opConcept,opConNegation,absorbableNominalVariableSet);
249 }
250 return oneAbsorbable;
251 } else if (negation && (opCode == CCOR) || !negation && (opCode == CCAND)) {
252 QSet<CConcept*> allAbsorbableNominalVariableSet;
253 bool allAbsorbableNominalVariableSetInitialized = false;
254 bool allAbsorbable = true;
255 for (CSortedNegLinker<CConcept*>* opLinkerIt = concept->getOperandList(); opLinkerIt; opLinkerIt = opLinkerIt->getNext()) {
256 CConcept* opConcept = opLinkerIt->getData();
257 bool opConNegation = opLinkerIt->isNegated() ^ negation;
258 QSet<CConcept*> tmpAbsorbableNominalVariableSet;
259 allAbsorbable &= findAbsorbableNominalSchemas(opConcept,opConNegation,&tmpAbsorbableNominalVariableSet);
260 if (!allAbsorbableNominalVariableSetInitialized) {
261 allAbsorbableNominalVariableSetInitialized = true;
262 allAbsorbableNominalVariableSet = tmpAbsorbableNominalVariableSet;
263 } else {
264 QSet<CConcept*>::iterator it = allAbsorbableNominalVariableSet.begin();
265 while (it != allAbsorbableNominalVariableSet.end()) {
266 if (tmpAbsorbableNominalVariableSet.contains(*it)) {
267 ++it;
268 } else {
269 it = allAbsorbableNominalVariableSet.erase(it);
270 }
271 }
272 }
273 }
274 *absorbableNominalVariableSet += allAbsorbableNominalVariableSet;
275 return allAbsorbable;
276 } else if (negation && (opCode == CCATLEAST && param > 0) || !negation && (opCode == CCATMOST && param >= 0)) {
277 bool oneAbsorbable = false;
278 for (CSortedNegLinker<CConcept*>* opLinkerIt = concept->getOperandList(); opLinkerIt; opLinkerIt = opLinkerIt->getNext()) {
279 CConcept* opConcept = opLinkerIt->getData();
280 bool opConNegation = opLinkerIt->isNegated();
281 oneAbsorbable |= findAbsorbableNominalSchemas(opConcept,opConNegation,absorbableNominalVariableSet);
282 }
283 return oneAbsorbable;
284 } else if (negation && (opCode == CCNOMVAR)) {
285 absorbableNominalVariableSet->insert(concept);
286 return true;
287 }
288 return false;
289 }
290
291 void CFullNominalSchemaGroundingPreProcess::addConceptOperand(CConcept* concept, CConcept* opConcept, bool negated) {
292 CSortedNegLinker<CConcept*>* opConLinker = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
293 opConLinker->init(opConcept,negated);
294 concept->addOperandLinker(opConLinker);
295 concept->incOperandCount();
296 }
297
298
299 CConcept* CFullNominalSchemaGroundingPreProcess::createNominalSchemaConceptCopy(CConcept* concept) {
300 CConcept* conceptCopy = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan);
301 conceptCopy->initConceptCopy(concept);
302 conceptCopy->setOperandCount(0);
303 conceptCopy->setConceptTag(mTBox->getNextConceptID());
304 mConceptVec->setData(conceptCopy->getConceptTag(),conceptCopy);
305 ++mStatCreatedConceptCount;
306 return conceptCopy;
307 }
308
309
310 CConcept* CFullNominalSchemaGroundingPreProcess::createGroundedNominalSchemaConcept(CConcept* concept, CBOXHASH<CConcept*,CConcept*>* templConNomSchConHash, QHash<CConcept*, QSet<CConcept*>::const_iterator >* nomSchConIndividualItHash) {
311
312 if (templConNomSchConHash->contains(concept)) {
313
314 cint64 opCode = concept->getOperatorCode();
315 if (opCode == CCNOMVAR) {
316 QSet<CConcept*>::const_iterator nomVarIt = nomSchConIndividualItHash->value(concept);
317 CConcept* nominalConcept = *nomVarIt;
318 return nominalConcept;
319 }
320
321 QByteArray conceptNomSchemIndiConceptByteArray;
322 if (mConfReuseGroundedNominalSchemaConcepts) {
323 conceptNomSchemIndiConceptByteArray.append(QByteArray::number((cint64)concept));
324 FOREACHIT (CConcept* nomSchemConcept, templConNomSchConHash->values(concept)) {
325 QSet<CConcept*>::const_iterator nomVarIt = nomSchConIndividualItHash->value(nomSchemConcept);
326 CConcept* indiConcept = *nomVarIt;
327 conceptNomSchemIndiConceptByteArray.append(QByteArray::number((cint64)indiConcept));
328 }
329 CConcept* replaceCon = mConceptNomSchemIndiReplaceHash.value(conceptNomSchemIndiConceptByteArray,nullptr);
330 if (replaceCon) {
331 return replaceCon;
332 }
333 }
334
335 CConcept* copiedConcept = createNominalSchemaConceptCopy(concept);
336
337 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
338 CConcept* opConcept = opConLinkerIt->getData();
339 bool opConNegation = opConLinkerIt->isNegated();
340
341 CConcept* newOpConcept = createGroundedNominalSchemaConcept(opConcept,templConNomSchConHash,nomSchConIndividualItHash);
342 addConceptOperand(copiedConcept,newOpConcept,opConNegation);
343 }
344
345 if (mConfReuseGroundedNominalSchemaConcepts) {
346 mConceptNomSchemIndiReplaceHash.insert(conceptNomSchemIndiConceptByteArray,copiedConcept);
347 }
348
349 return copiedConcept;
350 } else {
351 return concept;
352 }
353
354 }
355
356
357 CConcept* CFullNominalSchemaGroundingPreProcess::createNominalSchemaAxiomCollectionConcept(CConcept* concept, bool negated, CNominalSchemaTemplate* nsTemplate) {
358 ++mStatReplacedConceptCount;
359 if (mCollConHash.contains(QPair<CConcept*,bool>(concept,negated))) {
360 return mCollConHash.value(QPair<CConcept*,bool>(concept,negated));
361 }
362
363 ++mStatGroundedTemplateCount;
364
365 CConcept* collConcept = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan);
366 collConcept->initConcept();
367 collConcept->setConceptTag(mTBox->getNextConceptID());
368 collConcept->setOperatorCode(CCAND);
369 mConceptVec->setData(collConcept->getConceptTag(),collConcept);
370
371
372 CBOXHASH<CConcept*,CConcept*>* templConNomSchConHash = nsTemplate->getTemplateConceptNominalSchemaConceptHash();
373 CBOXSET<CConcept*>* nomSchConSet = nsTemplate->getNominalSchemaConceptSet();
374
375 QHash<CConcept*, QSet<CConcept*>::const_iterator > nomSchConIndividualItHash;
376 QSet<CConcept*>::const_iterator indiIt = mNominalConceptSet.constBegin();
377 QSet<CConcept*>::const_iterator indiItEnd = mNominalConceptSet.constEnd();
378 FOREACHIT (CConcept* nomSchCon, *nomSchConSet) {
379 nomSchConIndividualItHash.insert(nomSchCon,indiIt);
380 }
381
382
383
384 bool conVarItFinished = false;
385 while (!conVarItFinished) {
386 ++mStatInstantiatedAxiomsCount;
387
388
389 CConcept* templateConcept = nsTemplate->getTemplateConcept();
390 CConcept* groundedConcept = createGroundedNominalSchemaConcept(templateConcept,templConNomSchConHash,&nomSchConIndividualItHash);
391 addConceptOperand(collConcept,groundedConcept,negated);
392
393
394
395
396
397 QHash<CConcept*, QSet<CConcept*>::const_iterator >::const_iterator variableIt = nomSchConIndividualItHash.constBegin();
398 QHash<CConcept*, QSet<CConcept*>::const_iterator >::const_iterator variableItEnd = nomSchConIndividualItHash.constEnd();
399
400
401 QSet<CConcept*>::const_iterator varIndiIt = variableIt.value();
402 CConcept* varConcept = variableIt.key();
403
404 ++varIndiIt;
405 bool conVarIteration = true;
406 while (varIndiIt == indiItEnd && conVarIteration) {
407 conVarIteration = false;
408 nomSchConIndividualItHash.insert(varConcept,indiIt);
409
410 ++variableIt;
411 if (variableIt == variableItEnd) {
412 conVarItFinished = true;
413 } else {
414 varIndiIt = variableIt.value();
415 varConcept = variableIt.key();
416 ++varIndiIt;
417
418 if (varIndiIt == indiItEnd) {
419 conVarIteration = true;
420 }
421 }
422 }
423 nomSchConIndividualItHash.insert(varConcept,varIndiIt);
424 }
425
426
427 mCollConHash.insert(QPair<CConcept*,bool>(concept,negated),collConcept);
428 return collConcept;
429 }
430
431
432 }; // end namespace Preprocess
433
434 }; // end namespace Reasoner
435
436 }; // end namespace Konclude