fr.lirmm.graphik.integraal.forward_chaining.ChaseWithGRDAndUnfiers Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of integraal-graal-ruleset-analysis Show documentation
Show all versions of integraal-graal-ruleset-analysis Show documentation
Rule base analysis for InteGraal. This is imported from Graal
The newest version!
/*
* Copyright (C) Inria Sophia Antipolis - Méditerranée / LIRMM
* (Université de Montpellier & CNRS) (2014 - 2017)
*
* Contributors :
*
* Clément SIPIETER
* Mélanie KÖNIG
* Swan ROCHER
* Jean-François BAGET
* Michel LECLÈRE
* Marie-Laure MUGNIER
*
*
* This file is part of Graal
*
*/
public class ChaseWithGRDAndUnfiers extends AbstractChase {
private GraphOfRuleDependencies grd;
private T atomSet;
private Queue> queue = new LinkedList>();
private ChaseHaltingCondition hc = new RestrictedChaseHaltingCondition();
// /////////////////////////////////////////////////////////////////////////
// CONSTRUCTOR
// /////////////////////////////////////////////////////////////////////////
public ChaseWithGRDAndUnfiers(GraphOfRuleDependencies grd, T atomSet, RuleApplier ruleApplier) {
super(ruleApplier);
this.grd = grd;
this.atomSet = atomSet;
for(Rule r : grd.getRules()) {
this.queue.add(new ImmutableTriple(r, new HashMapSubstitution(), new DefaultInMemoryAtomSet()));
}
}
public ChaseWithGRDAndUnfiers(GraphOfRuleDependencies grd, T atomSet) {
this(grd, atomSet, new DefaultRuleApplier());
}
public ChaseWithGRDAndUnfiers(Iterator rules, T atomSet) {
this(new DefaultGraphOfRuleDependencies(rules, true), atomSet, new DefaultRuleApplier());
}
// /////////////////////////////////////////////////////////////////////////
// METHODS
// /////////////////////////////////////////////////////////////////////////
@Override
public void next() throws ChaseException {
Rule rule, unifiedRule;
Substitution unificator;
Queue> newQueue = new LinkedList>();
InMemoryAtomSet newAtomSet = new DefaultInMemoryGraphStore();
try {
while(!queue.isEmpty()) {
Triple pair = queue.poll();
if(pair != null) {
unificator = pair.getMiddle();
InMemoryAtomSet part = pair.getRight();
rule = pair.getLeft();
unifiedRule = DefaultUnifierAlgorithm.getTargetVariablesSubstitution().createImageOf(rule);
unifiedRule = unificator.createImageOf(unifiedRule);
unifiedRule.getBody().removeAll(part);
unificator = targetToSource(unificator);
ConjunctiveQuery query = DefaultConjunctiveQueryFactory.instance().create(unifiedRule.getBody(),
new LinkedList(unifiedRule.getFrontier()));
// Get projections
List projections = Iterators.toList(SmartHomomorphism.instance().execute(query, atomSet));
try {
for(Substitution proj : projections) {
InMemoryAtomSet newFacts = proj.createImageOf(unifiedRule.getHead());
ConjunctiveQuery q = new DefaultConjunctiveQuery(newFacts);
if (!SmartHomomorphism.instance().execute(q, newAtomSet).hasNext()) {
// Existential variables instantiation added to proj
CloseableIterator it = hc.apply(unifiedRule, proj, atomSet);
if (it.hasNext()) {
DefaultInMemoryAtomSet foundPart = new DefaultInMemoryAtomSet();
foundPart.addAll(it);
newAtomSet.addAll(foundPart);
// Makes the projection compatible with triggered rules unifiers
Substitution compatibleProj = targetToSource(proj);
for (Pair p : this.grd.getTriggeredRulesWithUnifiers(rule)) {
Rule triggeredRule = p.getKey();
Substitution u = p.getValue();
if(u != null) {
Substitution comp = unificator.compose(u);
Substitution aggreg = compatibleProj.aggregate(comp);
aggreg = forgetSource(aggreg);
if(aggreg != null) {
newQueue.add(new ImmutableTriple(triggeredRule, aggreg, foundPart));
}
}
}
}
}
}
} catch (HomomorphismFactoryException e) {
throw new RuleApplicationException("Error during rule application", e);
} catch (HomomorphismException e) {
throw new RuleApplicationException("Error during rule application", e);
} catch (IteratorException e) {
throw new RuleApplicationException("Error during rule application", e);
}
}
}
queue = newQueue;
atomSet.addAll(newAtomSet);
} catch (Exception e) {
e.printStackTrace();
throw new ChaseException("An error occur pending saturation step.", e);
}
}
@Override
public boolean hasNext() {
return !queue.isEmpty();
}
/**
* @param s
* @return a Substitution which is obtained by replacing all target mark (T::) from the specified substitution by a source mark (S::).
*/
private static Substitution targetToSource(Substitution s) {
Substitution res = DefaultSubstitutionFactory.instance().createSubstitution();
for(Variable v : s.getTerms()) {
res.put(DefaultTermFactory.instance().createVariable(v.getLabel().replaceAll("T::", "S::")), s.createImageOf(v));
}
return res;
}
private static Substitution forgetSource(Substitution s) {
Substitution res = DefaultSubstitutionFactory.instance().createSubstitution();
for(Variable v : s.getTerms()) {
if(v.getLabel().startsWith("T::")) {
res.put(v, s.createImageOf(v));
}
}
return res;
}
}