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 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 void TestSymbolTransform()
{
Sentence symbol = parser.Parse("A");
ConjunctionOfClauses transformed = ConvertToConjunctionOfClauses.Convert(symbol);
Assert.AreEqual("{{A}}", transformed.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 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 testThreeSuccessiveNotsTransformation()
{
Sentence threeNots = parser.parse("~~~A");
ConjunctionOfClauses transformed = ConvertToConjunctionOfClauses.convert(threeNots);
Assert.AreEqual("{{~A}}", transformed.ToString());
}
public void testDeMorgan1()
{
Sentence dm = parser.parse("~(A & B)");
ConjunctionOfClauses transformed = ConvertToConjunctionOfClauses.convert(dm);
Assert.AreEqual("{{~A, ~B}}", transformed.ToString());
}
public void testOrDistribution1()
{
Sentence or = parser.parse("A & B | C)");
ConjunctionOfClauses transformed = ConvertToConjunctionOfClauses.convert(or);
Assert.AreEqual("{{A, C}, {B, C}}", 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 TestDeMorgan2()
{
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());
}
/**
* 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));
}
}
/**
* Añade la sentencia específica a la BC.
*
* @param aSentence
* hecho para ser añadido a la BC.
*/
public void Tell(Sentence aSentence)
{
if (!(sentences.Contains(aSentence)))
{
sentences.Add(aSentence);
_asCNF = _asCNF.Extend(ConvertToConjunctionOfClauses.Convert(aSentence).GetClauses());
symbols.UnionWith(SymbolCollector.GetSymbolsFrom(aSentence)); // UnionWith de ISet en vez del método addAll de Set
}
}
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());
}
/**
* 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 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));
}
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());
}
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();
}
}
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);
}
//
// 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 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());
}
