public SymbolValuePair FindPureSymbolValuePair(IList <Sentence> clauseList,
Model model)
{
IList <Sentence> clausesWithNonTrueValues = ClausesWithNonTrueValues(clauseList, model);
Sentence nonTrueClauses = LogicUtils.ChainWith("AND", clausesWithNonTrueValues);
// System.out.println("Unsatisfied clauses = "
// + clausesWithNonTrueValues.Count);
ISet <Symbol> symbolsAlreadyAssigned = model.GetAssignedSymbols();
// debug
// IList symList = asList(symbolsAlreadyAssigned);
//
// System.out.println(" assignedSymbols = " + symList.Count);
// if (symList.Count == 52) {
// System.out.println("untrue clauses = " + clausesWithNonTrueValues);
// System.out.println("model= " + model);
// }
// debug
IList <Symbol> purePositiveSymbols = new SymbolClassifier().GetPurePositiveSymbolsIn(nonTrueClauses)
.Except(symbolsAlreadyAssigned).ToList();
IList <Symbol> pureNegativeSymbols =
new SymbolClassifier().GetPureNegativeSymbolsIn(nonTrueClauses).Except(symbolsAlreadyAssigned).ToList();
// if none found return "not found
if ((purePositiveSymbols.Count == 0) &&
(pureNegativeSymbols.Count == 0))
{
return(new SymbolValuePair());// automatically set to null values
}
else
{
if (purePositiveSymbols.Count > 0)
{
Symbol symbol = new Symbol((purePositiveSymbols[0])
.Value);
if (pureNegativeSymbols.Contains(symbol))
{
throw new ApplicationException("Symbol " + symbol.Value
+ "misclassified");
}
return(new SymbolValuePair(symbol, true));
}
else
{
Symbol symbol = new Symbol((pureNegativeSymbols[0])
.Value);
if (purePositiveSymbols.Contains(symbol))
{
throw new ApplicationException("Symbol " + symbol.Value
+ "misclassified");
}
return(new SymbolValuePair(symbol, false));
}
}
}
private IList <Sentence> FilterOutClausesWithTwoComplementaryLiterals(IList <Sentence> clauses)
{
var classifier = new SymbolClassifier();
return((from clause in clauses
let positiveSymbols = classifier.GetPositiveSymbolsIn(clause)
let negativeSymbols = classifier.GetNegativeSymbolsIn(clause)
where positiveSymbols.Intersect(negativeSymbols).Count() == 0
select clause).ToList());
}
private bool IsClauseTrueInModel(Sentence clause, Model model)
{
IList <Symbol> positiveSymbols = new SymbolClassifier().GetPositiveSymbolsIn(clause).ToList();
IList <Symbol> negativeSymbols = new SymbolClassifier().GetNegativeSymbolsIn(clause).ToList();
if (positiveSymbols.Any(symbol => (model.IsTrue(symbol))))
{
return(true);
}
return(negativeSymbols.Any(symbol => (model.IsFalse(symbol))));
}
public ClauseSymbols(Sentence clause1, Sentence clause2)
{
SymbolClassifier classifier = new SymbolClassifier();
clause1Symbols = classifier.getSymbolsIn(clause1);
clause1PositiveSymbols = classifier.getPositiveSymbolsIn(clause1);
clause1NegativeSymbols = classifier.getNegativeSymbolsIn(clause1);
clause2Symbols = classifier.getSymbolsIn(clause2);
clause2PositiveSymbols = classifier.getPositiveSymbolsIn(clause2);
clause2NegativeSymbols = classifier.getNegativeSymbolsIn(clause2);
positiveInClause1NegativeInClause2 = SetOps.intersection(
clause1PositiveSymbols, clause2NegativeSymbols);
negativeInClause1PositiveInClause2 = SetOps.intersection(
clause1NegativeSymbols, clause2PositiveSymbols);
}
public ClauseSymbols(Sentence clause1, Sentence clause2)
{
SymbolClassifier classifier = new SymbolClassifier();
this.Clause1Symbols = classifier.GetSymbolsIn(clause1);
this.Clause1PositiveSymbols = classifier.GetPositiveSymbolsIn(clause1);
this.Clause1NegativeSymbols = classifier.GetNegativeSymbolsIn(clause1);
this.Clause2Symbols = classifier.GetSymbolsIn(clause2);
this.Clause2PositiveSymbols = classifier.GetPositiveSymbolsIn(clause2);
this.Clause2NegativeSymbols = classifier.GetNegativeSymbolsIn(clause2);
this.PositiveInClause1NegativeInClause2 =
this.Clause1PositiveSymbols.Intersect(this.Clause2NegativeSymbols).ToList();
this.NegativeInClause1PositiveInClause2 =
this.Clause1NegativeSymbols.Intersect(this.Clause2PositiveSymbols).ToList();
}
//
// PRIVATE METHODS
//
private List <Sentence> filterOutClausesWithTwoComplementaryLiterals(
List <Sentence> clauses)
{
List <Sentence> filtered = new List <Sentence>();
SymbolClassifier classifier = new SymbolClassifier();
foreach (Sentence clause in clauses)
{
List <Symbol> positiveSymbols = classifier
.getPositiveSymbolsIn(clause);
List <Symbol> negativeSymbols = classifier
.getNegativeSymbolsIn(clause);
if ((SetOps.intersection(positiveSymbols, negativeSymbols).Count == 0))
{
filtered.Add(clause);
}
}
return(filtered);
}
private bool isClauseTrueInModel(Sentence clause, Model model)
{
List <Symbol> positiveSymbols = new SymbolClassifier().getPositiveSymbolsIn(clause);
List <Symbol> negativeSymbols = new SymbolClassifier().getNegativeSymbolsIn(clause);
foreach (Symbol symbol in positiveSymbols)
{
if ((model.isTrue(symbol)))
{
return(true);
}
}
foreach (Symbol symbol in negativeSymbols)
{
if ((model.isFalse(symbol)))
{
return(true);
}
}
return(false);
}
public void setUp()
{
classifier = new SymbolClassifier();
parser = new PEParser();
}
