public Model FindModelFor(String logicalSentence, int numberOfFlips,
double probabilityOfRandomWalk)
{
this.myModel = new Model();
var s = (Sentence) new PEParser().Parse(logicalSentence);
var transformer = new CNFTransformer();
var clauseGatherer = new CNFClauseGatherer();
var sc = new SymbolCollector();
var symbols = sc.GetSymbolsIn(s).ToList();
var r = new Random();
foreach (var sym in symbols)
{
this.myModel = this.myModel.Extend(sym, Util.RandomBoolean());
}
IList <Sentence> clauses = clauseGatherer.GetClausesFrom(transformer.Transform(s)).ToList();
//IList<Sentence> ClauseSet = new Converter<Sentence>().ListToSet(clauses);
lastClauses = clauses;
lastClausesFlip = new List <Int64>(clauses.Count + 1);
for (int i = 0; i < clauses.Count; i++)
{
lastClausesFlip.Add(0);
}
for (int i = 0; i < numberOfFlips; i++)
{
List <int> unsatList = new List <int>();
int numSat = this.GetNumberOfClausesSatisfiedIn(new Converter <Sentence>().ListToSet(clauses), myModel, unsatList);
if (numSat == clauses.Count)
{
trials = i;
return(myModel);
}
int probe = FindAnRandomUnsatisfiedClause(clauses, myModel, unsatList);
//Sentence clause = clauses[random.Next(clauses.Count)];
Sentence clause = clauses[probe];
lastClausesFlip[probe]++;
IList <Symbol> symbolsInClause = sc.GetSymbolsIn(clause).ToList();
if (random.NextDouble() >= probabilityOfRandomWalk)
{
Symbol randomSymbol = symbolsInClause[random.Next(symbolsInClause.Count)];
myModel = myModel.Flip(randomSymbol);
}
else
{
Symbol symbolToFlip = this.GetSymbolWhoseFlipMaximisesSatisfiedClauses(
new Converter <Sentence>().ListToSet(clauses),
symbolsInClause, myModel);
myModel = myModel.Flip(symbolToFlip);
}
}
trials = numberOfFlips;
return(null);
}
public bool DPLLSatisfiable(Sentence s, Model m)
{
ISet <Sentence> clauses = new CNFClauseGatherer().GetClausesFrom(new CNFTransformer().Transform(s));
IList <Symbol> symbols = SymbolConverter.SetToList(new SymbolCollector().GetSymbolsIn(s));
// System.out.println(" numberOfSymbols = " + symbols.Count);
return(Dpll(clauses, symbols, m));
}
public bool dpllSatisfiable(Sentence s, Model m)
{
List <Sentence> clauses = new CNFClauseGatherer()
.getClausesFrom(new CNFTransformer().transform(s));
List <Symbol> symbols = new SymbolCollector()
.getSymbolsIn(s);
// System.Console.WriteLine(" numberOfSymbols = " + symbols.Count);
return(dpll(clauses, symbols, m));
}
public void testDPLLFilteringNonTrueClausesGivesNullWhenAllClausesAreKnown()
{
Model model = new Model();
model = model.extend(new Symbol("A"), true).extend(new Symbol("B"),
true).extend(new Symbol("C"), true);
Sentence sentence = (Sentence)parser
.parse("((A AND B) AND (B AND C))");
List <Sentence> clauseList = new CNFClauseGatherer()
.getClausesFrom(new CNFTransformer()
.transform(sentence));
List <Sentence> clausesWithNonTrueValues = dpll
.clausesWithNonTrueValues(clauseList, model);
Assert.AreEqual(0, clausesWithNonTrueValues.Count);
}
public Model findModelFor(String logicalSentence, int numberOfFlips,
double probabilityOfRandomWalk)
{
myModel = new Model();
Sentence s = (Sentence) new PEParser().parse(logicalSentence);
CNFTransformer transformer = new CNFTransformer();
CNFClauseGatherer clauseGatherer = new CNFClauseGatherer();
SymbolCollector sc = new SymbolCollector();
List <Symbol> symbols = sc.getSymbolsIn(s);
Random r = new Random();
for (int i = 0; i < symbols.Count; i++)
{
Symbol sym = (Symbol)symbols[i];
myModel = myModel.extend(sym, Util.randombool());
}
List <Sentence> clauses = clauseGatherer.getClausesFrom(transformer
.transform(s));
for (int i = 0; i < numberOfFlips; i++)
{
if (getNumberOfClausesSatisfiedIn(clauses, myModel) == clauses.Count)
{
return(myModel);
}
Sentence clause = clauses[random.Next(clauses.Count)];
List <Symbol> symbolsInClause = sc
.getSymbolsIn(clause);
if (random.NextDouble() >= probabilityOfRandomWalk)
{
Symbol randomSymbol = symbolsInClause[random
.Next(symbolsInClause.Count)];
myModel = myModel.flip(randomSymbol);
}
else
{
Symbol symbolToFlip = getSymbolWhoseFlipMaximisesSatisfiedClauses(
clauses,
symbolsInClause, myModel);
myModel = myModel.flip(symbolToFlip);
}
}
return(null);
}
public void testDPLLFindsPurePositiveSymbolsWhenTheyExist()
{
Model model = new Model();
model = model.extend(new Symbol("A"), true).extend(new Symbol("B"),
true);
Sentence sentence = (Sentence)parser
.parse("((A AND B) AND (B AND C))");
List <Sentence> clauseList = new CNFClauseGatherer()
.getClausesFrom(new CNFTransformer()
.transform(sentence));
List <Symbol> symbolList = new SymbolCollector().getSymbolsIn(sentence);
DPLL.SymbolValuePair sv = dpll.findPureSymbolValuePair(clauseList,
model, symbolList);
Assert.IsNotNull(sv);
Assert.AreEqual(new Symbol("C"), sv.symbol);
Assert.AreEqual(true, sv.value);
}
public void testDPLLFiltersClausesTheStatusOfWhichAreKnown()
{
Model model = new Model();
model = model.extend(new Symbol("A"), true).extend(new Symbol("B"),
true);
Sentence sentence = (Sentence)parser
.parse("((A AND B) AND (B AND C))");
List <Sentence> clauseList = new CNFClauseGatherer()
.getClausesFrom(new CNFTransformer()
.transform(sentence));
List <Sentence> clausesWithNonTrueValues = dpll
.clausesWithNonTrueValues(clauseList, model);
Assert.AreEqual(1, clausesWithNonTrueValues.Count);
Sentence nonTrueClause = (Sentence)parser.parse("(B AND C)");
clausesWithNonTrueValues.Contains(nonTrueClause);
}
public bool plResolution(KnowledgeBase kb, Sentence alpha)
{
Sentence kBAndNotAlpha = new BinarySentence("AND", kb.asSentence(),
new UnarySentence(alpha));
List <Sentence> clauses = new CNFClauseGatherer()
.getClausesFrom(new CNFTransformer().transform(kBAndNotAlpha));
clauses = filterOutClausesWithTwoComplementaryLiterals(clauses);
List <Sentence> newClauses = new List <Sentence>();
while (true)
{
List <List <Sentence> > pairs = getCombinationPairs(clauses);
for (int i = 0; i < pairs.Count; i++)
{
List <Sentence> pair = pairs[i];
// System.Console.WriteLine("pair number" + i+" of "+pairs.Count);
List <Sentence> resolvents = plResolve(pair[0], pair[1]);
resolvents = filterOutClausesWithTwoComplementaryLiterals(resolvents);
if (resolvents.Contains(new Symbol("EMPTY_CLAUSE")))
{
return(true);
}
newClauses = SetOps.union(newClauses, resolvents);
// System.Console.WriteLine("clauseslist size = " +clauses.Count);
}
if (SetOps.intersection(newClauses, clauses).Count == newClauses
.Count)
{// subset test
return(false);
}
clauses = SetOps.union(newClauses, clauses);
clauses = filterOutClausesWithTwoComplementaryLiterals(clauses);
}
}
public bool PlResolution(KnowledgeBase kb, Sentence alpha)
{
Sentence kBAndNotAlpha = new BinarySentence("AND", kb.AsSentence(),
new UnarySentence(alpha));
IList <Sentence> clauses = new CNFClauseGatherer()
.GetClausesFrom(new CNFTransformer().Transform(kBAndNotAlpha)).ToList();
clauses = this.FilterOutClausesWithTwoComplementaryLiterals(clauses);
var newClauses = new List <Sentence>();
while (true)
{
IList <IList <Sentence> > pairs = this.GetCombinationPairs(clauses.ToList());
for (int i = 0; i < pairs.Count; i++)
{
IList <Sentence> pair = pairs[i];
// System.out.println("pair number" + i+" of "+pairs.Count);
IList <Sentence> resolvents = this.PLResolve(pair[0], pair[1]);
resolvents = this.FilterOutClausesWithTwoComplementaryLiterals(resolvents);
if (resolvents.Contains(new Symbol("EMPTY_CLAUSE")))
{
return(true);
}
newClauses = newClauses.Union(resolvents).ToList();
// System.out.println("clauseslist size = " +clauses.Count);
}
if (newClauses.Intersect(clauses).Count() == newClauses.Count)
{// subset test
return(false);
}
clauses = newClauses.Union(clauses).ToList();
clauses = this.FilterOutClausesWithTwoComplementaryLiterals(clauses);
}
}
public void setUp()
{
parser = new PEParser();
gatherer = new CNFClauseGatherer();
}
