/** * Remove clauses where variable v has value newValue. Also remove variables from clauses where it * has !newValue. */ public void reduce(int val, int newValue) { int newVariable = 0; int notVariable = 0; if (val < 0 && newValue == -1) { newVariable = val; } else if (val < 0 && newValue == 1) { newVariable = val * -1; } else { newVariable = val * newValue; } notVariable = -newVariable; Iterator<Clause> iter = clauses.iterator(); while (iter.hasNext()) { Clause c = iter.next(); for (int i = 0; i < c.getVariables().size(); i++) { int var = c.getVariables().get(i); if (var == newVariable) { /* remove this clause */ finalVars.add(newVariable); iter.remove(); break; } else if (var == notVariable) { c.getVariables().remove(i); i--; } } } }
/** * Gets the "flip value" of setting this var to newValue. If setting var to newValue resulted in * breaking two expressions and fixing one, the retval would be -1. * * @param val the variable to set * @param newValue the value of the variable (1 for true, -1 for false) */ public int getFlipValue(int val, int newValue) { int newVariable = 0; int notVariable = 0; int flipVal = 0; if (val < 0 && newValue == -1) { newVariable = val; } else if (val < 0 && newValue == 1) { newVariable = val * -1; } else { newVariable = val * newValue; } notVariable = -newVariable; for (Clause c : clauses) { int varSize = c.getVariables().size(); for (int i = 0; i < varSize; i++) { int var = c.getVariables().get(i); if (var == newVariable) { flipVal++; break; } else if (c.isSatisfied() && c.getSatisfiedVar() == notVariable) { flipVal--; } } } return flipVal; }
/** * Goes through every variable in c, and if the flip value did not break anything, add it to * retval. * * @param val the variable to set * @param newValue the value of the variable (1 for true, -1 for false) */ public ArrayList<Integer> getPositiveFlips(Clause c) { ArrayList<Integer> retval = new ArrayList<Integer>(); int varSize = c.getVariables().size(); for (int i = 0; i < varSize; i++) { int var = c.getVariables().get(i); int newValue = (var < 0) ? -1 : 1; if (isPositiveFlip(var, newValue)) retval.add(var); } return retval; }
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; }
/** * Copy constructor * * @param f */ public Formula(Formula f) { this(); for (Clause c : f.getClauses()) { Clause temp = new Clause(); int varSize = c.getVariables().size(); for (int i = 0; i < varSize; i++) { Integer newVar = new Integer(c.getVariables().get(i)); temp.addVariable(newVar); } this.clauses.add(temp); } this.getFinalVars().addAll(f.getFinalVars()); }
/** * Sets the variable in the formula * * @param val the variable to set * @param newValue the value of the variable (1 for true, -1 for false) */ public void setVariable(int val, int newValue) { int newVariable = 0; int notVariable = 0; if (val < 0 && newValue == -1) { newVariable = val; } else if (val < 0 && newValue == 1) { newVariable = val * -1; } else { newVariable = val * newValue; } notVariable = -newVariable; for (Clause c : clauses) { int varSize = c.getVariables().size(); for (int i = 0; i < varSize; i++) { int var = c.getVariables().get(i); if (var == newVariable) { c.setSatisfiedVar(var); break; } else if (c.isSatisfied() && c.getSatisfiedVar() == notVariable) { c.setSatisfiedVar(0); } } } }
/** * Returns true if flipping this variable breaks nothing, false otherwise * * @param val * @param newValue * @return */ public boolean isPositiveFlip(int val, int newValue) { int newVariable = 0; int notVariable = 0; if (val < 0 && newValue == -1) { newVariable = val; } else if (val < 0 && newValue == 1) { newVariable = val * -1; } else { newVariable = val * newValue; } notVariable = -newVariable; for (Clause c : clauses) { int varSize = c.getVariables().size(); for (int i = 0; i < varSize; i++) { if (c.isSatisfied() && c.getSatisfiedVar() == notVariable) { return false; } } } return true; }