ParamodulationTest.java

package aima.test.core.unit.logic.fol.inference;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

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

import aima.core.logic.fol.domain.FOLDomain;
import aima.core.logic.fol.inference.Paramodulation;
import aima.core.logic.fol.kb.data.Clause;
import aima.core.logic.fol.kb.data.Literal;
import aima.core.logic.fol.parsing.FOLParser;
import aima.core.logic.fol.parsing.ast.AtomicSentence;

/**
 * @author Ciaran O'Reilly
 * 
 */
public class ParamodulationTest {

	private Paramodulation paramodulation = null;

	@Before
	public void setUp() {
		paramodulation = new Paramodulation();
	}

	// Note: Based on:
	// http://logic.stanford.edu/classes/cs157/2008/lectures/lecture15.pdf
	// Slide 31.
	@Test
	public void testSimpleExample() {
		FOLDomain domain = new FOLDomain();
		domain.addConstant("A");
		domain.addConstant("B");
		domain.addPredicate("P");
		domain.addPredicate("Q");
		domain.addPredicate("R");
		domain.addFunction("F");

		FOLParser parser = new FOLParser(domain);

		List<Literal> lits = new ArrayList<Literal>();
		AtomicSentence a1 = (AtomicSentence) parser.parse("P(F(x,B),x)");
		AtomicSentence a2 = (AtomicSentence) parser.parse("Q(x)");
		lits.add(new Literal(a1));
		lits.add(new Literal(a2));

		Clause c1 = new Clause(lits);

		lits.clear();
		a1 = (AtomicSentence) parser.parse("F(A,y) = y");
		a2 = (AtomicSentence) parser.parse("R(y)");
		lits.add(new Literal(a1));
		lits.add(new Literal(a2));

		Clause c2 = new Clause(lits);

		Set<Clause> paras = paramodulation.apply(c1, c2);
		Assert.assertEquals(2, paras.size());

		Iterator<Clause> it = paras.iterator();
		Assert.assertEquals("[P(B,A), Q(A), R(B)]", it.next().toString());
		Assert.assertEquals("[P(F(A,F(x,B)),x), Q(x), R(F(x,B))]", it.next()
				.toString());
	}

	@Test
	public void testMultipleTermEqualitiesInBothClausesExample() {
		FOLDomain domain = new FOLDomain();
		domain.addConstant("A");
		domain.addConstant("B");
		domain.addConstant("C");
		domain.addConstant("D");
		domain.addPredicate("P");
		domain.addPredicate("Q");
		domain.addPredicate("R");
		domain.addFunction("F");

		FOLParser parser = new FOLParser(domain);

		List<Literal> lits = new ArrayList<Literal>();
		AtomicSentence a1 = (AtomicSentence) parser.parse("F(C,x) = D");
		AtomicSentence a2 = (AtomicSentence) parser.parse("A = D");
		AtomicSentence a3 = (AtomicSentence) parser.parse("P(F(x,B),x)");
		AtomicSentence a4 = (AtomicSentence) parser.parse("Q(x)");
		AtomicSentence a5 = (AtomicSentence) parser.parse("R(C)");
		lits.add(new Literal(a1));
		lits.add(new Literal(a2));
		lits.add(new Literal(a3));
		lits.add(new Literal(a4));
		lits.add(new Literal(a5));

		Clause c1 = new Clause(lits);

		lits.clear();
		a1 = (AtomicSentence) parser.parse("F(A,y) = y");
		a2 = (AtomicSentence) parser.parse("F(B,y) = C");
		a3 = (AtomicSentence) parser.parse("R(y)");
		a4 = (AtomicSentence) parser.parse("R(A)");
		lits.add(new Literal(a1));
		lits.add(new Literal(a2));
		lits.add(new Literal(a3));
		lits.add(new Literal(a4));

		Clause c2 = new Clause(lits);

		Set<Clause> paras = paramodulation.apply(c1, c2);
		Assert.assertEquals(5, paras.size());

		Iterator<Clause> it = paras.iterator();
		Assert.assertEquals(
				"[F(B,B) = C, F(C,A) = D, A = D, P(B,A), Q(A), R(A), R(B), R(C)]",
				it.next().toString());
		Assert.assertEquals(
				"[F(A,F(C,x)) = D, F(B,F(C,x)) = C, A = D, P(F(x,B),x), Q(x), R(F(C,x)), R(A), R(C)]",
				it.next().toString());
		Assert.assertEquals(
				"[F(A,B) = B, F(C,B) = D, A = D, P(C,B), Q(B), R(A), R(B), R(C)]",
				it.next().toString());
		Assert.assertEquals(
				"[F(F(B,y),x) = D, F(A,y) = y, A = D, P(F(x,B),x), Q(x), R(y), R(A), R(C)]",
				it.next().toString());
		Assert.assertEquals(
				"[F(B,y) = C, F(C,x) = D, F(D,y) = y, P(F(x,B),x), Q(x), R(y), R(A), R(C)]",
				it.next().toString());
	}

	@Test
	public void testBypassReflexivityAxiom() {
		FOLDomain domain = new FOLDomain();
		domain.addConstant("A");
		domain.addConstant("B");
		domain.addConstant("C");
		domain.addPredicate("P");
		domain.addFunction("F");

		FOLParser parser = new FOLParser(domain);

		List<Literal> lits = new ArrayList<Literal>();
		AtomicSentence a1 = (AtomicSentence) parser.parse("P(y, F(A,y))");
		lits.add(new Literal(a1));

		Clause c1 = new Clause(lits);

		lits.clear();
		a1 = (AtomicSentence) parser.parse("x = x");
		lits.add(new Literal(a1));

		Clause c2 = new Clause(lits);

		Set<Clause> paras = paramodulation.apply(c1, c2);
		Assert.assertEquals(0, paras.size());
	}

	@Test
	public void testNegativeTermEquality() {
		FOLDomain domain = new FOLDomain();
		domain.addConstant("A");
		domain.addConstant("B");
		domain.addConstant("C");
		domain.addPredicate("P");
		domain.addFunction("F");

		FOLParser parser = new FOLParser(domain);

		List<Literal> lits = new ArrayList<Literal>();
		AtomicSentence a1 = (AtomicSentence) parser.parse("P(y, F(A,y))");
		lits.add(new Literal(a1));

		Clause c1 = new Clause(lits);

		lits.clear();
		a1 = (AtomicSentence) parser.parse("F(x,B) = x");
		lits.add(new Literal(a1, true));

		Clause c2 = new Clause(lits);

		Set<Clause> paras = paramodulation.apply(c1, c2);
		Assert.assertEquals(0, paras.size());
	}
}