public void testFourSuccessiveNotsTransformation() { Sentence fourNots = parser.parse("~~~~A"); ConjunctionOfClauses transformed = ConvertToConjunctionOfClauses.convert(fourNots); Assert.AreEqual("{{A}}", transformed.ToString()); }
public bool Ask(KnowledgeBase kb, string predicate) { switch (Procedure) { case PLInferenceProcedure.TTEntails: return(kb.askWithTTEntails(predicate)); case PLInferenceProcedure.PLFCEntails: return(new PLFCEntails().plfcEntails(kb, new PropositionSymbol(predicate))); case PLInferenceProcedure.Resolve: return(new PLResolution().plResolution(kb, (Sentence)parser.parse(predicate))); case PLInferenceProcedure.DPLLEntails: return(new DPLLSatisfiable().isEntailed(kb, (Sentence)parser.parse(predicate))); case PLInferenceProcedure.DPLLSatisfiable: return(new DPLLSatisfiable().dpllSatisfiable((Sentence)parser.parse(predicate))); case PLInferenceProcedure.WalkSatPredicate: return(new WalkSAT().walkSAT(ConvertToConjunctionOfClauses.convert((Sentence)parser.parse(predicate)).getClauses(), WalkSatProbability, WalkSatMaxFlips) != null); case PLInferenceProcedure.WalkSatKb: return(new WalkSAT().walkSAT(kb.asCNF(), WalkSatProbability, WalkSatMaxFlips) != null); default: throw new ArgumentOutOfRangeException(); } }
public void testSymbolTransform() { Sentence symbol = parser.parse("A"); ConjunctionOfClauses transformed = ConvertToConjunctionOfClauses.convert(symbol); Assert.AreEqual("{{A}}", transformed.ToString()); }
public void testBiConditionalTransformation() { Sentence bic = parser.parse("A <=> B"); ConjunctionOfClauses transformedBic = ConvertToConjunctionOfClauses.convert(bic); Assert.AreEqual("{{~A, B}, {~B, A}}", transformedBic.ToString()); }
public void testNested() { Sentence nested = parser.parse("A | (B | (C | (D & E)))"); ConjunctionOfClauses transformed = ConvertToConjunctionOfClauses.convert(nested); Assert.AreEqual("{{A, B, C, D}, {A, B, C, E}}", transformed.ToString()); nested = parser.parse("A | (B | (C & (D & E)))"); transformed = ConvertToConjunctionOfClauses.convert(nested); Assert.AreEqual("{{A, B, C}, {A, B, D}, {A, B, E}}", transformed.ToString()); nested = parser.parse("A | (B | (C & (D & (E | F))))"); transformed = ConvertToConjunctionOfClauses.convert(nested); Assert.AreEqual("{{A, B, C}, {A, B, D}, {A, B, E, F}}", transformed.ToString()); nested = parser.parse("(A | (B | (C & D))) | E | (F | (G | (H & I)))"); transformed = ConvertToConjunctionOfClauses.convert(nested); Assert.AreEqual("{{A, B, C, E, F, G, H}, {A, B, D, E, F, G, H}, {A, B, C, E, F, G, I}, {A, B, D, E, F, G, I}}", transformed.ToString()); nested = parser.parse("(((~P | ~Q) => ~(P | Q)) => R)"); transformed = ConvertToConjunctionOfClauses.convert(nested); Assert.AreEqual("{{~P, ~Q, R}, {P, Q, R}}", transformed.ToString()); nested = parser.parse("~(((~P | ~Q) => ~(P | Q)) => R)"); transformed = ConvertToConjunctionOfClauses.convert(nested); Assert.AreEqual("{{P, ~P}, {Q, ~P}, {P, ~Q}, {Q, ~Q}, {~R}}", transformed.ToString()); }
public void testAimaExample() { Sentence aimaEg = parser.parse("B11 <=> P12 | P21"); ConjunctionOfClauses transformed = ConvertToConjunctionOfClauses.convert(aimaEg); Assert.AreEqual("{{~B11, P12, P21}, {~P12, B11}, {~P21, B11}}", transformed.ToString()); }
public void testOrDistribution2() { Sentence or = parser.parse("A | B & C"); ConjunctionOfClauses transformed = ConvertToConjunctionOfClauses.convert(or); Assert.AreEqual("{{A, B}, {A, C}}", transformed.ToString()); }
public static void Main(params string[] args) { System.Console.WriteLine("\nWalkSatDemo\n"); KnowledgeBase kb = new KnowledgeBase(); kb.tell("P => Q"); kb.tell("L & M => P"); kb.tell("B & L => M"); kb.tell("A & P => L"); kb.tell("A & B => L"); kb.tell("A"); kb.tell("B"); System.Console.WriteLine("Example from page 220 of AIMA 2nd Edition"); System.Console.WriteLine("KnowledgeBsse consists of sentences"); System.Console.WriteLine(kb.ToString()); WalkSAT walkSAT = new WalkSAT(); Model m = walkSAT.walkSAT(ConvertToConjunctionOfClauses.convert(kb.asSentence()).getClauses(), 0.5, 1000); if (m == null) { System.Console.WriteLine("failure"); } else { m.print(); } }
public void testImplicationTransformation() { Sentence impl = parser.parse("A => B"); ConjunctionOfClauses transformedImpl = ConvertToConjunctionOfClauses.convert(impl); Assert.AreEqual("{{~A, B}}", transformedImpl.ToString()); }
public void testDeMorgan1() { Sentence dm = parser.parse("~(A & B)"); ConjunctionOfClauses transformed = ConvertToConjunctionOfClauses.convert(dm); Assert.AreEqual("{{~A, ~B}}", transformed.ToString()); }
public void testIssue78() { // ( ( NOT J1007 ) OR ( NOT ( OR J1008 J1009 J1010 J1011 J1012 J1013 J1014 J1015 ) ) ) Sentence issue78Eg = parser.parse("( ( ~ J1007 ) | ( ~ ( J1008 | J1009 | J1010 | J1011 | J1012 | J1013 | J1014 | J1015 ) ) )"); ConjunctionOfClauses transformed = ConvertToConjunctionOfClauses.convert(issue78Eg); Assert.AreEqual("{{~J1007, ~J1008}, {~J1007, ~J1009}, {~J1007, ~J1010}, {~J1007, ~J1011}, {~J1007, ~J1012}, {~J1007, ~J1013}, {~J1007, ~J1014}, {~J1007, ~J1015}}", transformed.ToString()); }
public void testPLResolveWithNoLiteralMatching() { Clause one = Util.first(ConvertToConjunctionOfClauses.convert(parser.parse("A | B")).getClauses()); Clause two = Util.first(ConvertToConjunctionOfClauses.convert(parser.parse("C | D")).getClauses()); ISet <Clause> resolvents = resolution.plResolve(one, two); Assert.AreEqual(0, resolvents.Size()); }
/** * Adds the specified sentence to the knowledge base. * * @param aSentence * a fact to be added to the knowledge base. */ public void tell(Sentence aSentence) { if (!(sentences.Contains(aSentence))) { sentences.Add(aSentence); _asCNF = _asCNF.extend(ConvertToConjunctionOfClauses.convert(aSentence).getClauses()); symbols.AddAll(SymbolCollector.getSymbolsFrom(aSentence)); } }
/** * DPLL-SATISFIABLE?(s)<br> * Checks the satisfiability of a sentence in propositional logic. * * @param s * a sentence in propositional logic. * @return true if the sentence is satisfiable, false otherwise. */ public bool dpllSatisfiable(Sentence s) { // clauses <- the set of clauses in the CNF representation of s ISet <Clause> clauses = ConvertToConjunctionOfClauses.convert(s).getClauses(); // symbols <- a list of the proposition symbols in s ICollection <PropositionSymbol> symbols = getPropositionSymbolsInSentence(s); // return DPLL(clauses, symbols, {}) return(dpll(clauses, symbols, new Model())); }
public void testPLResolveWithOneLiteralSentencesMatching() { Clause one = Util.first(ConvertToConjunctionOfClauses.convert(parser.parse("A")).getClauses()); Clause two = Util.first(ConvertToConjunctionOfClauses.convert(parser.parse("~A")).getClauses()); ISet <Clause> resolvents = resolution.plResolve(one, two); Assert.AreEqual(1, resolvents.Size()); Assert.IsTrue(Util.first(resolvents).isEmpty()); Assert.IsTrue(Util.first(resolvents).isFalse()); }
public void testPLResolveWithOneLiteralMatching() { Clause one = Util.first(ConvertToConjunctionOfClauses.convert(parser.parse("A | B")).getClauses()); Clause two = Util.first(ConvertToConjunctionOfClauses.convert(parser.parse("~B | C")).getClauses()); Clause expected = Util.first(ConvertToConjunctionOfClauses.convert(parser.parse("A | C")).getClauses()); ISet <Clause> resolvents = resolution.plResolve(one, two); Assert.AreEqual(1, resolvents.Size()); Assert.IsTrue(resolvents.Contains(expected)); }
protected ISet <Clause> setOfClausesInTheCNFRepresentationOfKBAndNotAlpha(KnowledgeBase kb, Sentence alpha) { // KB & ~alpha; Sentence isContradiction = new ComplexSentence(Connective.AND, kb.asSentence(), new ComplexSentence(Connective.NOT, alpha)); // the set of clauses in the CNF representation ISet <Clause> clauses = CollectionFactory.CreateSet <Clause>(ConvertToConjunctionOfClauses.convert(isContradiction).getClauses()); discardTautologies(clauses); return(clauses); }
public void testWalkSat2() { WalkSAT walkSAT = new WalkSAT(); Model m = walkSAT.walkSAT(ConvertToConjunctionOfClauses.convert(parser.parse("A & ~B")) .getClauses(), 0.5, 1000); if (m == null) { System.Console.WriteLine("failure"); } else { m.print(); } }
// // SUPPORTING CODE // /** * Determine if KB |= α, i.e. alpha is entailed by KB. * * @param kb * a Knowledge Base in propositional logic. * @param alpha * a propositional sentence. * @return true, if α is entailed by KB, false otherwise. */ public bool isEntailed(KnowledgeBase kb, Sentence alpha) { // AIMA3e p.g. 260: kb |= alpha, can be done by testing // unsatisfiability of kb & ~alpha. ISet <Clause> kbAndNotAlpha = CollectionFactory.CreateSet <Clause>(); Sentence notQuery = new ComplexSentence(Connective.NOT, alpha); ISet <PropositionSymbol> symbols = CollectionFactory.CreateSet <PropositionSymbol>(); ICollection <PropositionSymbol> querySymbols = CollectionFactory.CreateQueue <PropositionSymbol>(SymbolCollector.getSymbolsFrom(notQuery)); kbAndNotAlpha.AddAll(kb.asCNF()); kbAndNotAlpha.AddAll(ConvertToConjunctionOfClauses.convert(notQuery).getClauses()); symbols.AddAll(querySymbols); symbols.AddAll(kb.getSymbols()); return(!dpll(kbAndNotAlpha, CollectionFactory.CreateQueue <PropositionSymbol>(symbols), new Model())); }
public void testDPLLReturnsFalseWhenOneClauseFalseInModel() { Model model = new Model(); model = model.union(new PropositionSymbol("A"), true).union( new PropositionSymbol("B"), false); Sentence sentence = parser.parse("(A | B) & (A => B)"); ISet <Clause> clauses = ConvertToConjunctionOfClauses.convert(sentence) .getClauses(); ICollection <PropositionSymbol> symbols = CollectionFactory.CreateQueue <PropositionSymbol>( SymbolCollector.getSymbolsFrom(sentence)); bool satisfiable = dpll.dpll(clauses, symbols, model); Assert.AreEqual(false, satisfiable); }
public void testPLResolveWithTwoLiteralsMatching() { Clause one = Util.first(ConvertToConjunctionOfClauses.convert(parser.parse("~P21 | B11")).getClauses()); Clause two = Util.first(ConvertToConjunctionOfClauses.convert(parser.parse("~B11 | P21 | P12")).getClauses()); ISet <Clause> expected = ConvertToConjunctionOfClauses.convert(parser.parse("(P12 | P21 | ~P21) & (B11 | P12 | ~B11)")).getClauses(); ISet <Clause> resolvents = resolution.plResolve(one, two); int numberExpectedResolvents = 2; if (resolution.isDiscardTautologies()) { numberExpectedResolvents = 0; // due to being tautologies } Assert.AreEqual(numberExpectedResolvents, resolvents.Size()); Assert.AreEqual(numberExpectedResolvents, SetOps.intersection(expected, resolvents).Size()); }
public void testBasicSentenceTransformation() { Sentence and = parser.parse("A & B"); ConjunctionOfClauses transformedAnd = ConvertToConjunctionOfClauses.convert(and); Assert.AreEqual("{{A}, {B}}", transformedAnd.ToString()); Sentence or = parser.parse("A | B"); ConjunctionOfClauses transformedOr = ConvertToConjunctionOfClauses.convert(or); Assert.AreEqual("{{A, B}}", transformedOr.ToString()); Sentence not = parser.parse("~C"); ConjunctionOfClauses transformedNot = ConvertToConjunctionOfClauses.convert(not); Assert.AreEqual("{{~C}}", transformedNot.ToString()); }
public void testIssue66() { // http://code.google.com/p/aima-java/issues/detail?id=66 Model model = new Model(); model = model.union(new PropositionSymbol("A"), false) .union(new PropositionSymbol("B"), false) .union(new PropositionSymbol("C"), true); Sentence sentence = parser.parse("((A | B) | C)"); ISet <Clause> clauses = ConvertToConjunctionOfClauses.convert(sentence) .getClauses(); ICollection <PropositionSymbol> symbols = CollectionFactory.CreateQueue <PropositionSymbol>( SymbolCollector.getSymbolsFrom(sentence)); bool satisfiable = dpll.dpll(clauses, symbols, model); Assert.AreEqual(true, satisfiable); }
protected IMap <Clause, int> initializeCount(KnowledgeBase kb) { // count <- a table, where count[c] is the number of symbols in c's // premise IMap <Clause, int> count = CollectionFactory.CreateInsertionOrderedMap <Clause, int>(); ISet <Clause> clauses = ConvertToConjunctionOfClauses.convert(kb.asSentence()).getClauses(); foreach (Clause c in clauses) { if (!c.isDefiniteClause()) { throw new IllegalArgumentException("Knowledge Base contains non-definite clauses:" + c); } // Note: # of negative literals is equivalent to the number of symbols in c's premise count.Put(c, c.getNumberNegativeLiterals()); } return(count); }
public void testAIMAExample() { KnowledgeBase kb = new KnowledgeBase(); kb.tell("P => Q"); kb.tell("L & M => P"); kb.tell("B & L => M"); kb.tell("A & P => L"); kb.tell("A & B => L"); kb.tell("A"); kb.tell("B"); WalkSAT walkSAT = new WalkSAT(); Model m = walkSAT.walkSAT(ConvertToConjunctionOfClauses.convert(kb.asSentence()) .getClauses(), 0.5, 1000); if (m == null) { System.Console.WriteLine("failure"); } else { m.print(); } }
protected ISet <Clause> translateToSAT(Describe init, Describe transition, Describe goal, int t) { Sentence s = ComplexSentence.newConjunction(init.assertions(t), transition.assertions(t), goal.assertions(t)); return(ConvertToConjunctionOfClauses.convert(s).getClauses()); }