PLResolutionTest.java

package aima.test.core.unit.logic.propositional.algorithms;

import java.util.Set;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import aima.core.logic.propositional.algorithms.KnowledgeBase;
import aima.core.logic.propositional.algorithms.PLResolution;
import aima.core.logic.propositional.parsing.PEParser;
import aima.core.logic.propositional.parsing.ast.Sentence;
import aima.core.logic.propositional.parsing.ast.Symbol;

/**
 * @author Ravi Mohan
 * 
 */
public class PLResolutionTest {
	private PLResolution resolution;

	private PEParser parser;

	@Before
	public void setUp() {
		resolution = new PLResolution();
		parser = new PEParser();
	}

	@Test
	public void testPLResolveWithOneLiteralMatching() {
		Sentence one = (Sentence) parser.parse("(A OR B)");
		Sentence two = (Sentence) parser.parse("((NOT B) OR C)");
		Sentence expected = (Sentence) parser.parse("(A OR C)");
		Set<Sentence> resolvents = resolution.plResolve(one, two);
		Assert.assertEquals(1, resolvents.size());
		Assert.assertTrue(resolvents.contains(expected));
	}

	@Test
	public void testPLResolveWithNoLiteralMatching() {
		Sentence one = (Sentence) parser.parse("(A OR B)");
		Sentence two = (Sentence) parser.parse("(C OR D)");
		Set<Sentence> resolvents = resolution.plResolve(one, two);
		Assert.assertEquals(0, resolvents.size());
	}

	@Test
	public void testPLResolveWithOneLiteralSentencesMatching() {
		Sentence one = (Sentence) parser.parse("A");
		Sentence two = (Sentence) parser.parse("(NOT A)");
		// Sentence expected =(Sentence) parser.parse("(A OR C)");
		Set<Sentence> resolvents = resolution.plResolve(one, two);
		Assert.assertEquals(1, resolvents.size());
		Assert.assertTrue(resolvents.contains(new Symbol("EMPTY_CLAUSE")));
	}

	@Test
	public void testPLResolveWithTwoLiteralsMatching() {
		Sentence one = (Sentence) parser.parse("((NOT P21) OR B11)");
		Sentence two = (Sentence) parser.parse("(((NOT B11) OR P21) OR P12)");
		Sentence expected1 = (Sentence) parser
				.parse("(  ( P12 OR P21 ) OR  ( NOT P21 )  )");
		Sentence expected2 = (Sentence) parser
				.parse("(  ( B11 OR P12 ) OR  ( NOT B11 )  )");
		Set<Sentence> resolvents = resolution.plResolve(one, two);

		Assert.assertEquals(2, resolvents.size());
		Assert.assertTrue(resolvents.contains(expected1));
		Assert.assertTrue(resolvents.contains(expected2));
	}

	@Test
	public void testPLResolve1() {
		boolean b = resolution.plResolution("((B11 =>  (NOT P11)) AND B11)",
				"(P11)");
		Assert.assertEquals(false, b);
	}

	@Test
	public void testPLResolve2() {
		boolean b = resolution.plResolution("(A AND B)", "B");
		Assert.assertEquals(true, b);
	}

	@Test
	public void testPLResolve3() {
		boolean b = resolution.plResolution("((B11 =>  (NOT P11)) AND B11)",
				"(NOT P11)");
		Assert.assertEquals(true, b);
	}

	@Test
	public void testPLResolve4() {
		boolean b = resolution.plResolution("(A OR B)", "B");
		Assert.assertEquals(false, b);
	}

	@Test
	public void testPLResolve5() {
		boolean b = resolution.plResolution("((B11 =>  (NOT P11)) AND B11)",
				"(NOT B11)");
		Assert.assertEquals(false, b);
	}

	@Test
	public void testMultipleClauseResolution() {
		// test (and fix) suggested by Huy Dinh. Thanks Huy!
		PLResolution plr = new PLResolution();
		KnowledgeBase kb = new KnowledgeBase();
		String fact = "((B11 <=> (P12 OR P21)) AND (NOT B11))";
		kb.tell(fact);
		plr.plResolution(kb, "(B)");
	}

	// public void testPLResolutionWithChadCarfBugReportData() {
	// commented out coz this needs a major fix wait for a rewrite
	// KnowledgeBase kb = new KnowledgeBase();
	// kb.tell("(B12 <=> (P11 OR (P13 OR (P22 OR P02))))");
	// kb.tell("(B21 <=> (P20 OR (P22 OR (P31 OR P11))))");
	// kb.tell("(B01 <=> (P00 OR (P02 OR P11)))");
	// kb.tell("(B10 <=> (P11 OR (P20 OR P00)))");
	// kb.tell("(NOT B21)");
	// kb.tell("(NOT B12)");
	// kb.tell("(B10)");
	// kb.tell("(B01)");
	// assertTrue(resolution.plResolution(kb.asSentence().toString(), "(P00)"));
	// //assertFalse(kb.askWithDpll("(NOT P00)"));
	//
	//
	// }
}