public Substitution getAssociatedSubstitution() { if (associatedSubstitution == null) { associatedSubstitution = TermPartitionUtils.getAssociatedSubstitution(partition, query); } return DefaultSubstitutionFactory.instance().createSubstitution(associatedSubstitution); }
@Override public Substitution aggregate(Substitution s) { Substitution newSub = DefaultSubstitutionFactory.instance().createSubstitution(this); for (Variable term : s.getTerms()) { if (!newSub.aggregate(term, s.createImageOf(term))) { return null; } } return newSub; }
public static Substitution aggregate(Substitution s1, Substitution s2) { Substitution newSub = DefaultSubstitutionFactory.instance().createSubstitution(s1); for (Variable term : s2.getTerms()) { if (!newSub.aggregate(term, s2.createImageOf(term))) { return null; } } return newSub; }
@Override public Substitution compose(Substitution s) { Substitution newSub = DefaultSubstitutionFactory.instance().createSubstitution(this); for (Variable term : s.getTerms()) { if (!newSub.compose(term, s.createImageOf(term))) { return null; } } return newSub; }
/** * Return all possible rewritings of this Atom by this compilation. */ @Override public Collection<Pair<Atom, Substitution>> getRewritingOf(Atom atom) { TreeSet<Pair<Atom, Substitution>> res = new TreeSet<Pair<Atom, Substitution>>(); res.add(new ImmutablePair<Atom, Substitution>(atom, DefaultSubstitutionFactory.instance().createSubstitution())); Predicate predH = atom.getPredicate(); Map<Predicate, LinkedList<IDCondition>> condH = this.conditions .get(predH); if (condH != null) { LinkedList<IDCondition> conds; Predicate predB; for (Map.Entry<Predicate, LinkedList<IDCondition>> entry : condH .entrySet()) { predB = entry.getKey(); conds = entry.getValue(); for (IDCondition cond : conds) { Pair<List<Term>, Substitution> ret = cond.generateBody(atom.getTerms()); if (ret != null) { List<Term> generatedBody = ret.getLeft(); res.add(new ImmutablePair<Atom, Substitution>(new DefaultAtom(predB, generatedBody), ret.getRight())); } } } } return res; }
@Override public Pair<List<Term>, Substitution> generateBody(List<Term> head) { Substitution s = DefaultSubstitutionFactory.instance().createSubstitution(); Set<Variable> toRemoveFromPartition = new TreeSet<Variable>(); for (int i = 0; i < condHead.length; i++) { Variable v = DefaultTermFactory.instance().createVariable(condHead[i]); toRemoveFromPartition.add(v); if (!s.aggregate(v, head.get(i))) { return null; } } List<Term> body = new ArrayList<Term>(condBody.length); for (int i = 0; i < condBody.length; i++) { Variable v = DefaultTermFactory.instance().createVariable(condBody[i]); toRemoveFromPartition.add(v); body.add(s.createImageOf(v)); } for (Variable v : toRemoveFromPartition) { s.remove(v); } return new ImmutablePair<List<Term>, Substitution>(body, s); }
@Override public Collection<Substitution> homomorphism(Atom father, Atom son) { LinkedList<Substitution> res = new LinkedList<Substitution>(); if (isMappable(father.getPredicate(), son.getPredicate())) { Substitution sub = DefaultSubstitutionFactory.instance().createSubstitution(); Iterator<Term> fatherTermsIt = father.getTerms().iterator(); Iterator<Term> sonTermsIt = son.getTerms().iterator(); Term fatherTerm, sonTerm; while (fatherTermsIt.hasNext() && sonTermsIt.hasNext()) { fatherTerm = fatherTermsIt.next(); sonTerm = sonTermsIt.next(); if (fatherTerm.isConstant()) { if (!fatherTerm.equals(sonTerm)) { return res; } } else if (!sub.getTerms().contains(fatherTerm)) sub.put((Variable) fatherTerm, sonTerm); else if (!sub.createImageOf(fatherTerm).equals(sonTerm)) return res; } res.add(sub); } return res; }
@Override public Collection<Substitution> homomorphism(Atom father, Atom son) { LinkedList<Substitution> res = new LinkedList<Substitution>(); if (father.getPredicate().equals(son.getPredicate())) { Substitution sub = DefaultSubstitutionFactory.instance().createSubstitution(); Iterator<Term> fatherTermsIt = father.getTerms().iterator(); Iterator<Term> sonTermsIt = son.getTerms().iterator(); Term fatherTerm, sonTerm; while (fatherTermsIt.hasNext() && sonTermsIt.hasNext()) { fatherTerm = fatherTermsIt.next(); sonTerm = sonTermsIt.next(); if (fatherTerm.isConstant()) { if (!fatherTerm.equals(sonTerm)) { return res; } } else if (!sub.getTerms().contains(fatherTerm)) sub.put((Variable) fatherTerm, sonTerm); else if (!sub.createImageOf(fatherTerm).equals(sonTerm)) return res; } res.add(sub); } return res; }
Substitution homo = DefaultSubstitutionFactory.instance().createSubstitution(); List<Term> generatedBody = ret.getLeft();
Substitution substitution = DefaultSubstitutionFactory.instance().createSubstitution();
private static Substitution unifier(Substitution baseUnifier, Atom a1, Atom a2, Set<Variable> frontierVars, Set<Variable> existentialVars) { if (a1.getPredicate().equals(a2.getPredicate())) { boolean error = false; Substitution u = DefaultSubstitutionFactory.instance().createSubstitution(); u.put(baseUnifier); for (int i = 0; i < a1.getPredicate().getArity(); ++i) { Term t1 = a1.getTerm(i); Term t2 = a2.getTerm(i); error = error || !compose(u, frontierVars, existentialVars, t1, t2); } if (!error) return u; } return null; }
private static InMemoryAtomSet computeFixedQuery(InMemoryAtomSet atomset, Iterable<? extends Term> fixedTerms) { // create a Substitution for fixed query InMemoryAtomSet fixedQuery = DefaultAtomSetFactory.instance().create(); Substitution fixSub = DefaultSubstitutionFactory.instance().createSubstitution(); for (Term t : fixedTerms) { if(t.isVariable()) { fixSub.put((Variable) t, DefaultTermFactory.instance().createConstant(t.getLabel())); } } // apply substitution CloseableIteratorWithoutException<Atom> it = atomset.iterator(); while (it.hasNext()) { Atom a = it.next(); fixedQuery.add(fixSub.createImageOf(a)); } return fixedQuery; }