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>()); }