/**
* 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;
}
