public ArrayList<Clause> generateResolvents( Clause givenClause, Collection<Clause> workedOffClauses) { ArrayList<Clause> result = new ArrayList<Clause>(); // If the head of givenClause is selected, then givenClause is the side premise if (givenClause.m_selectedHead) { for (Clause workedOffClause : workedOffClauses) { for (int mainPremiseIndex = 0; mainPremiseIndex < workedOffClause.getBody().length; mainPremiseIndex++) { // If the body atom B of workedOffClause is selected and B has the same arity/name as the // head atom of givenClause, then try to resolve // System.out.println("Given: " + givenClause.getHead().getName()); // System.out.println(workedOffClause.getBody()[mainPremiseIndex].getName()); if ((workedOffClause.m_selectedBody[mainPremiseIndex]) && (workedOffClause.getBody()[mainPremiseIndex].getArity() == givenClause.getHead().getArity()) && (workedOffClause .getBody()[mainPremiseIndex] .getName() .equals(givenClause.getHead().getName()))) { Clause resolvent = resolve(workedOffClause, givenClause, mainPremiseIndex); if (resolvent != null) { result.add(resolvent); } } } } } // If a body atom of givenClause is selected, then givenClause is the main premise for (int mainPremiseIndex = 0; mainPremiseIndex < givenClause.getBody().length; mainPremiseIndex++) { if (givenClause.m_selectedBody[mainPremiseIndex]) { for (Clause workedOffClause : workedOffClauses) { // If the head atom B of workedOffClause is selected and B has the same arity/name as the // body atom of givenClause, then try to resolve if (workedOffClause.m_selectedHead && workedOffClause.getHead().getArity() == givenClause.getBody()[mainPremiseIndex].getArity() && workedOffClause .getHead() .getName() .equals(givenClause.getBody()[mainPremiseIndex].getName())) { Clause resolvent = resolve(givenClause, workedOffClause, mainPremiseIndex); if (resolvent != null) { result.add(resolvent); } } } } } return result; }
private Clause resolve(Clause mainPremise, Clause sidePremise, int mainPremiseAtomIndex) { // Rename the variables of the side premise int numberOfVariablesMainPremise = mainPremise.getVariables().size(); Clause sidePremiseRenamed = sidePremise.renameVariables( this.m_saturator.getTermFactory(), numberOfVariablesMainPremise); Term mainAtom = mainPremise.getBody()[mainPremiseAtomIndex]; Term sideAtom = sidePremiseRenamed.getHead(); Substitution unifier = Substitution.mostGeneralUnifier(mainAtom, sideAtom, this.m_saturator.getTermFactory()); if (unifier == null) return null; Set<Term> newBody = new LinkedHashSet<Term>(); // Copy the atoms from the main premise for (int index = 0; index < mainPremise.getBody().length; index++) { if (index != mainPremiseAtomIndex) { Term newBodyAtom = mainPremise.getBody()[index].apply(unifier, this.m_saturator.getTermFactory()); ((FunctionalTerm) newBodyAtom).originIndex = ((FunctionalTerm) mainPremise.getBody()[index]).originIndex; newBody.add(newBodyAtom); } } // Copy the atoms from the side premise for (int index = 0; index < sidePremiseRenamed.getBody().length; index++) { Term newBodyAtom = sidePremiseRenamed.getBody()[index].apply(unifier, this.m_saturator.getTermFactory()); ((FunctionalTerm) newBodyAtom).originIndex = ((FunctionalTerm) mainAtom).originIndex; newBody.add(newBodyAtom); } // New body and head Term[] body = new Term[newBody.size()]; newBody.toArray(body); Term head = mainPremise.getHead().apply(unifier, this.m_saturator.getTermFactory()); Clause resolvent = new Clause(body, head); // Rename variables in resolvent ArrayList<Variable> variablesResolvent = resolvent.getVariables(); HashMap<Variable, Integer> variableMapping = new HashMap<Variable, Integer>(); for (int i = 0; i < variablesResolvent.size(); i++) { variableMapping.put(variablesResolvent.get(i), i); } Clause resolventRenamed = resolvent.renameVariables(this.m_saturator.getTermFactory(), variableMapping); return resolventRenamed; }