public bool ttCheckAll(Sentence kbSentence, Sentence querySentence,
List<Symbol> symbols, Model model)
{
if (symbols.Count==0)
{
if (model.isTrue(kbSentence))
{
// System.Console.WriteLine("#");
return model.isTrue(querySentence);
}
else
{
// System.Console.WriteLine("0");
return true;
}
}
else
{
Symbol symbol = (Symbol)Util.first(symbols);
List<Symbol> rest = Util.rest(symbols);
Model trueModel = model.extend(new Symbol(symbol.getValue()), true);
Model falseModel = model.extend(new Symbol(symbol.getValue()),
false);
return (ttCheckAll(kbSentence, querySentence, rest, trueModel) && (ttCheckAll(
kbSentence, querySentence, rest, falseModel)));
}
}
public BinarySentence(String op, Sentence first, Sentence second)
{
this.op = op;
this.first = first;
this.second = second;
}
public List<Symbol> getSymbolsIn(Sentence s)
{
if (s == null)
{// empty knowledge bases == null fix this later
return new List<Symbol>();
}
return (List<Symbol>)s.accept(this, new List<Symbol>());
}
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 Sentence transform(Sentence s)
{
Sentence toTransform = s;
while (!(toTransform.Equals(step(toTransform))))
{
toTransform = step(toTransform);
}
return toTransform;
}
public void setUp()
{
parser = new PEParser();
trueSentence = (Sentence)parser.parse("true");
falseSentence = (Sentence)parser.parse("false");
andSentence = (Sentence)parser.parse("(P AND Q)");
orSentence = (Sentence)parser.parse("(P OR Q)");
impliedSentence = (Sentence)parser.parse("(P => Q)");
biConditionalSentence = (Sentence)parser.parse("(P <=> Q)");
m = new Model();
}
private bool FindSentence(List<Symbol> symbols, Sentence s)
{
foreach (Symbol symbol in symbols)
{
if (symbol is Sentence && symbol.Equals(s))
{
return true;
}
}
return false;
}
public List<Sentence> plResolve(Sentence clause1, Sentence clause2)
{
List<Sentence> resolvents = new List<Sentence>();
ClauseSymbols cs = new ClauseSymbols(clause1, clause2);
List<Symbol> complementedSymbols = cs.getComplementedSymbols();
foreach(Symbol symbol in complementedSymbols)
{
resolvents.Add(createResolventClause(cs, symbol));
}
return resolvents;
}
//
// PRIVATE METHODS
//
private List<Sentence> processSubTerm(Sentence s, List<Sentence> soFar)
{
if (detector.containsEmbeddedAnd(s))
{
return (List<Sentence>)s.accept(this, soFar);
}
else
{
soFar.Add(s);
return soFar;
}
}
public List<Sentence> getClausesFrom(Sentence sentence)
{
List<Sentence> set = new List<Sentence>();
if (sentence is Symbol)
{
set.Add(sentence);
}
else if (sentence is UnarySentence)
{
set.Add(sentence);
}
else
{
set = (List<Sentence>)sentence.accept(this, set);
}
return set;
}
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);
}
}
private Sentence step(Sentence s)
{
return (Sentence)s.accept(this, null);
}
public HornClause(Sentence sentence, PLFCEntails plfcEntails)
{
this.plfcEntails = plfcEntails;
if (sentence is Symbol)
{
_head = (Symbol)sentence;
plfcEntails.agenda.Push(_head);
premiseSymbols = new List<Symbol>();
plfcEntails.count.Add(this, 0);
plfcEntails._inferred.Add(_head, false);
}
else if (!isImpliedSentence(sentence))
{
throw new ApplicationException("Sentence " + sentence
+ " is not a horn clause");
}
else
{
BinarySentence bs = (BinarySentence)sentence;
_head = (Symbol)bs.getSecond();
if (plfcEntails._inferred.ContainsKey(_head))
{
plfcEntails._inferred[_head] = false;
}
else
{
plfcEntails._inferred.Add(_head, false);
}
List<Symbol> symbolsInPremise = new SymbolCollector()
.getSymbolsIn(bs.getFirst());
foreach(Symbol s in symbolsInPremise)
{
plfcEntails._inferred.Add(s, false);
}
premiseSymbols = symbolsInPremise;
plfcEntails.count.Add(this, premiseSymbols.Count);
}
}
public List<Symbol> getSymbolsIn(Sentence sentence)
{
return new SymbolCollector().getSymbolsIn(sentence);
}
private bool isImpliedSentence(Sentence sentence)
{
return ((sentence is BinarySentence) && ((BinarySentence)sentence)
.getOperator().Equals("=>"));
}
public List<Symbol> getPureSymbolsIn(Sentence sentence)
{
List<Symbol> allPureNegatives = getPureNegativeSymbolsIn(sentence);
List<Symbol> allPurePositives = getPurePositiveSymbolsIn(sentence);
return SetOps.union(allPurePositives, allPureNegatives);
}
public List<Symbol> getImpureSymbolsIn(Sentence sentence)
{
List<Symbol> allNegatives = getNegativeSymbolsIn(sentence);
List<Symbol> allPositives = getPositiveSymbolsIn(sentence);
return SetOps.intersection(allPositives, allNegatives);
}
public bool isTrue(Sentence clause) {
return clause.accept(this, null).Equals(true);
}
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);
}
// private const Converter<Symbol> SYMBOL_CONVERTER = new Converter<Symbol>();
public bool dpllSatisfiable(Sentence s)
{
return dpllSatisfiable(s, new Model());
}
public UnarySentence(Sentence negated)
{
this.negated = negated;
}
public bool isFalse(Sentence clause) {
return clause.accept(this, null).Equals(false);
}
public List<Symbol> getPositiveSymbolsIn(Sentence sentence)
{
return (List<Symbol>)sentence.accept(this, new List<Symbol>());
}
public bool isUnknown(Sentence clause) {
return null == clause.accept(this, null);
}
public bool containsEmbeddedAnd(Sentence s)
{
return (bool)s.accept(this, null);
}
public List<Symbol> getNegativeSymbolsIn(Sentence sentence)
{
return new NegativeSymbolCollector().getNegativeSymbolsIn(sentence);
}
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 List<Symbol> getPurePositiveSymbolsIn(Sentence sentence)
{
List<Symbol> allNegatives = getNegativeSymbolsIn(sentence);
List<Symbol> allPositives = getPositiveSymbolsIn(sentence);
return SetOps.difference(allPositives, allNegatives);
}
public List<Symbol> getNegativeSymbolsIn(Sentence s)
{
return (List<Symbol>)s.accept(this, new List<Symbol>());
}
public UnarySentence(Sentence negated)
{
this.negated = negated;
}
