/aima-core/src/test/java/aima/test/core/unit/logic/fol/UnifierTest.java

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



import java.util.ArrayList;

import java.util.Hashtable;

import java.util.List;

import java.util.Map;



import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;



import aima.core.logic.fol.Unifier;

import aima.core.logic.fol.domain.DomainFactory;

import aima.core.logic.fol.domain.FOLDomain;

import aima.core.logic.fol.parsing.FOLParser;

import aima.core.logic.fol.parsing.ast.Constant;

import aima.core.logic.fol.parsing.ast.Function;

import aima.core.logic.fol.parsing.ast.Predicate;

import aima.core.logic.fol.parsing.ast.Sentence;

import aima.core.logic.fol.parsing.ast.Term;

import aima.core.logic.fol.parsing.ast.TermEquality;

import aima.core.logic.fol.parsing.ast.Variable;



/**

 * @author Ravi Mohan

 * @author Ciaran O'Reilly

 */

public class UnifierTest {



	private FOLParser parser;

	private Unifier unifier;

	private Map<Variable, Term> theta;



	@Before

	public void setUp() {

		parser = new FOLParser(DomainFactory.knowsDomain());

		unifier = new Unifier();

		theta = new Hashtable<Variable, Term>();

	}



	@Test

	public void testFailureIfThetaisNull() {

		Variable var = new Variable("x");

		Sentence sentence = parser.parse("Knows(x)");

		theta = null;

		Map<Variable, Term> result = unifier.unify(var, sentence, theta);

		Assert.assertNull(result);

	}



	@Test

	public void testUnificationFailure() {

		Variable var = new Variable("x");

		Sentence sentence = parser.parse("Knows(y)");

		theta = null;

		Map<Variable, Term> result = unifier.unify(var, sentence, theta);

		Assert.assertNull(result);

	}



	@Test

	public void testThetaPassedBackIfXEqualsYBothVariables() {

		Variable var1 = new Variable("x");

		Variable var2 = new Variable("x");



		theta.put(new Variable("dummy"), new Variable("dummy"));

		Map<Variable, Term> result = unifier.unify(var1, var2, theta);

		Assert.assertEquals(theta, result);

		Assert.assertEquals(1, theta.keySet().size());

		Assert.assertTrue(theta.containsKey(new Variable("dummy")));

	}



	@Test

	public void testVariableEqualsConstant() {

		Variable var1 = new Variable("x");

		Constant constant = new Constant("John");



		Map<Variable, Term> result = unifier.unify(var1, constant, theta);

		Assert.assertEquals(theta, result);

		Assert.assertEquals(1, theta.keySet().size());

		Assert.assertTrue(theta.keySet().contains(var1));

		Assert.assertEquals(constant, theta.get(var1));

	}



	@Test

	public void testSimpleVariableUnification() {

		Variable var1 = new Variable("x");

		List<Term> terms1 = new ArrayList<Term>();

		terms1.add(var1);

		Predicate p1 = new Predicate("King", terms1); // King(x)



		List<Term> terms2 = new ArrayList<Term>();

		terms2.add(new Constant("John"));

		Predicate p2 = new Predicate("King", terms2); // King(John)



		Map<Variable, Term> result = unifier.unify(p1, p2, theta);

		Assert.assertEquals(theta, result);

		Assert.assertEquals(1, theta.keySet().size());

		Assert.assertTrue(theta.keySet().contains(new Variable("x"))); // x =

		Assert.assertEquals(new Constant("John"), theta.get(var1)); // John

	}



	@Test

	public void testKnows1() {

		Sentence query = parser.parse("Knows(John,x)");

		Sentence johnKnowsJane = parser.parse("Knows(John,Jane)");

		Map<Variable, Term> result = unifier.unify(query, johnKnowsJane, theta);

		Assert.assertEquals(theta, result);

		Assert.assertTrue(theta.keySet().contains(new Variable("x"))); // x =

		Assert.assertEquals(new Constant("Jane"), theta.get(new Variable("x"))); // Jane

	}



	@Test

	public void testKnows2() {

		Sentence query = parser.parse("Knows(John,x)");

		Sentence johnKnowsJane = parser.parse("Knows(y,Bill)");

		Map<Variable, Term> result = unifier.unify(query, johnKnowsJane, theta);



		Assert.assertEquals(2, result.size());



		Assert.assertEquals(new Constant("Bill"), theta.get(new Variable("x"))); // x

		// =

		// Bill

		Assert.assertEquals(new Constant("John"), theta.get(new Variable("y"))); // y

		// =

		// John

	}



	@Test

	public void testKnows3() {

		Sentence query = parser.parse("Knows(John,x)");

		Sentence johnKnowsJane = parser.parse("Knows(y,Mother(y))");

		Map<Variable, Term> result = unifier.unify(query, johnKnowsJane, theta);



		Assert.assertEquals(2, result.size());



		List<Term> terms = new ArrayList<Term>();

		terms.add(new Constant("John"));

		Function mother = new Function("Mother", terms);

		Assert.assertEquals(mother, theta.get(new Variable("x")));

		Assert.assertEquals(new Constant("John"), theta.get(new Variable("y")));

	}



	@Test

	public void testKnows5() {

		Sentence query = parser.parse("Knows(John,x)");

		Sentence johnKnowsJane = parser.parse("Knows(y,z)");

		Map<Variable, Term> result = unifier.unify(query, johnKnowsJane, theta);



		Assert.assertEquals(2, result.size());



		Assert.assertEquals(new Variable("z"), theta.get(new Variable("x"))); // x

		// =

		// z

		Assert.assertEquals(new Constant("John"), theta.get(new Variable("y"))); // y

		// =

		// John

	}



	@Test

	public void testCascadedOccursCheck() {

		FOLDomain domain = new FOLDomain();

		domain.addPredicate("P");

		domain.addFunction("F");

		domain.addFunction("SF0");

		domain.addFunction("SF1");

		FOLParser parser = new FOLParser(domain);



		Sentence s1 = parser.parse("P(SF1(v2),v2)");

		Sentence s2 = parser.parse("P(v3,SF0(v3))");

		Map<Variable, Term> result = unifier.unify(s1, s2);



		Assert.assertNull(result);



		s1 = parser.parse("P(v1,SF0(v1),SF0(v1),SF0(v1),SF0(v1))");

		s2 = parser.parse("P(v2,SF0(v2),v2,     v3,     v2)");

		result = unifier.unify(s1, s2);



		Assert.assertNull(result);



		s1 = parser

				.parse("P(v1,   F(v2),F(v2),F(v2),v1,      F(F(v1)),F(F(F(v1))),v2)");

		s2 = parser

				.parse("P(F(v3),v4,   v5,   v6,   F(F(v5)),v4,      F(v3),      F(F(v5)))");

		result = unifier.unify(s1, s2);



		Assert.assertNull(result);

	}



	/**

	 * From: TPTP:LCL418-1 Am performing an incorrect unification for:

	 * [is_a_theorem

	 * (equivalent(equivalent(c1744,c1743),equivalent(c1742,c1743))),

	 * is_a_theorem(equivalent(equivalent(c1752,c1751),c1752))]

	 * 

	 * which is giving the following substitution:

	 * 

	 * subst={c1744=equivalent(c1742,c1743), c1743=c1751,

	 * c1752=equivalent(c1742,c1751)}

	 * 

	 * which is incorrect as c1743 in the first function term needs to be c1751

	 * as this is the second substitution.

	 */

	@Test

	public void testBadCascadeSubstitution_LCL418_1() {

		FOLDomain domain = new FOLDomain();

		domain.addPredicate("ISATHEOREM");

		domain.addFunction("EQUIVALENT");

		FOLParser parser = new FOLParser(domain);



		Sentence s1 = parser

				.parse("ISATHEOREM(EQUIVALENT(EQUIVALENT(c1744,c1743),EQUIVALENT(c1742,c1743)))");

		Sentence s2 = parser

				.parse("ISATHEOREM(EQUIVALENT(EQUIVALENT(c1752,c1751),c1752))");

		Map<Variable, Term> result = unifier.unify(s1, s2);



		Assert.assertEquals(

				"{c1744=EQUIVALENT(c1742,c1751), c1743=c1751, c1752=EQUIVALENT(c1742,c1751)}",

				result.toString());

	}



	@Test

	public void testAdditionalVariableMixtures() {

		FOLDomain domain = new FOLDomain();

		domain.addConstant("A");

		domain.addConstant("B");

		domain.addFunction("F");

		domain.addFunction("G");

		domain.addFunction("H");

		domain.addPredicate("P");



		FOLParser parser = new FOLParser(domain);



		// Test Cascade Substitutions handled correctly

		Sentence s1 = parser.parse("P(z, x)");

		Sentence s2 = parser.parse("P(x, a)");

		Map<Variable, Term> result = unifier.unify(s1, s2);



		Assert.assertEquals("{z=a, x=a}", result.toString());



		s1 = parser.parse("P(x, z)");

		s2 = parser.parse("P(a, x)");

		result = unifier.unify(s1, s2);



		Assert.assertEquals("{x=a, z=a}", result.toString());



		s1 = parser.parse("P(w, w, w)");

		s2 = parser.parse("P(x, y, z)");

		result = unifier.unify(s1, s2);



		Assert.assertEquals("{w=z, x=z, y=z}", result.toString());



		s1 = parser.parse("P(x, y, z)");

		s2 = parser.parse("P(w, w, w)");

		result = unifier.unify(s1, s2);



		Assert.assertEquals("{x=w, y=w, z=w}", result.toString());



		s1 = parser.parse("P(x, B, F(y))");

		s2 = parser.parse("P(A, y, F(z))");

		result = unifier.unify(s1, s2);



		Assert.assertEquals("{x=A, y=B, z=B}", result.toString());



		s1 = parser.parse("P(F(x,B), G(y),         F(z,A))");

		s2 = parser.parse("P(y,      G(F(G(w),w)), F(w,z))");

		result = unifier.unify(s1, s2);



		Assert.assertNull(result);



		s1 = parser.parse("P(F(G(A)), x,    F(H(z,z)), H(y,    G(w)))");

		s2 = parser.parse("P(y,       G(z), F(v     ), H(F(w), x   ))");

		result = unifier.unify(s1, s2);



		Assert.assertEquals(

				"{y=F(G(A)), x=G(G(A)), v=H(G(A),G(A)), w=G(A), z=G(A)}",

				result.toString());

	}



	@Test

	public void testTermEquality() {

		FOLDomain domain = new FOLDomain();

		domain.addConstant("A");

		domain.addConstant("B");

		domain.addFunction("Plus");



		FOLParser parser = new FOLParser(domain);



		TermEquality te1 = (TermEquality) parser.parse("x = x");

		TermEquality te2 = (TermEquality) parser.parse("x = x");



		// Both term equalities the same,

		// should unify but no substitutions.

		Map<Variable, Term> result = unifier.unify(te1, te2);



		Assert.assertNotNull(result);

		Assert.assertEquals(0, result.size());



		// Different variable names but should unify.

		te1 = (TermEquality) parser.parse("x1 = x1");

		te2 = (TermEquality) parser.parse("x2 = x2");



		result = unifier.unify(te1, te2);



		Assert.assertNotNull(result);

		Assert.assertEquals(1, result.size());

		Assert.assertEquals("{x1=x2}", result.toString());



		// Test simple unification with reflexivity axiom

		te1 = (TermEquality) parser.parse("x1 = x1");

		te2 = (TermEquality) parser.parse("Plus(A,B) = Plus(A,B)");



		result = unifier.unify(te1, te2);



		Assert.assertNotNull(result);



		Assert.assertEquals(1, result.size());

		Assert.assertEquals("{x1=Plus(A,B)}", result.toString());



		// Test more complex unification with reflexivity axiom

		te1 = (TermEquality) parser.parse("x1 = x1");

		te2 = (TermEquality) parser.parse("Plus(A,B) = Plus(A,z1)");



		result = unifier.unify(te1, te2);



		Assert.assertNotNull(result);



		Assert.assertEquals(2, result.size());

		Assert.assertEquals("{x1=Plus(A,B), z1=B}", result.toString());



		// Test reverse of previous unification with reflexivity axiom

		// Should still be the same.

		te1 = (TermEquality) parser.parse("x1 = x1");

		te2 = (TermEquality) parser.parse("Plus(A,z1) = Plus(A,B)");



		result = unifier.unify(te1, te2);



		Assert.assertNotNull(result);



		Assert.assertEquals(2, result.size());

		Assert.assertEquals("{x1=Plus(A,B), z1=B}", result.toString());



		// Test with nested terms

		te1 = (TermEquality) parser

				.parse("Plus(Plus(Plus(A,B),B, A)) = Plus(Plus(Plus(A,B),B, A))");

		te2 = (TermEquality) parser

				.parse("Plus(Plus(Plus(A,B),B, A)) = Plus(Plus(Plus(A,B),B, A))");



		result = unifier.unify(te1, te2);



		Assert.assertNotNull(result);



		Assert.assertEquals(0, result.size());



		// Simple term equality unification fails

		te1 = (TermEquality) parser.parse("Plus(A,B) = Plus(B,A)");

		te2 = (TermEquality) parser.parse("Plus(A,B) = Plus(A,B)");



		result = unifier.unify(te1, te2);



		Assert.assertNull(result);

	}



	@Test

	public void testNOTSentence() {

		FOLDomain domain = new FOLDomain();

		domain.addConstant("A");

		domain.addConstant("B");

		domain.addConstant("C");

		domain.addFunction("Plus");

		domain.addPredicate("P");



		FOLParser parser = new FOLParser(domain);



		Sentence s1 = parser.parse("NOT(P(A))");

		Sentence s2 = parser.parse("NOT(P(A))");



		Map<Variable, Term> result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(0, result.size());



		s1 = parser.parse("NOT(P(A))");

		s2 = parser.parse("NOT(P(B))");



		result = unifier.unify(s1, s2);



		Assert.assertNull(result);



		s1 = parser.parse("NOT(P(A))");

		s2 = parser.parse("NOT(P(x))");



		result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(1, result.size());

		Assert.assertEquals(new Constant("A"), result.get(new Variable("x")));

	}



	@Test

	public void testConnectedSentence() {

		FOLDomain domain = new FOLDomain();

		domain.addConstant("A");

		domain.addConstant("B");

		domain.addConstant("C");

		domain.addFunction("Plus");

		domain.addPredicate("P");



		FOLParser parser = new FOLParser(domain);



		Sentence s1 = parser.parse("(P(A) AND P(B))");

		Sentence s2 = parser.parse("(P(A) AND P(B))");



		Map<Variable, Term> result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(0, result.size());



		s1 = parser.parse("(P(A) AND P(B))");

		s2 = parser.parse("(P(A) AND P(C))");



		result = unifier.unify(s1, s2);



		Assert.assertNull(result);



		s1 = parser.parse("(P(A) AND P(B))");

		s2 = parser.parse("(P(A) AND P(x))");



		result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(1, result.size());

		Assert.assertEquals(new Constant("B"), result.get(new Variable("x")));



		s1 = parser.parse("(P(A) OR P(B))");

		s2 = parser.parse("(P(A) OR P(B))");



		result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(0, result.size());



		s1 = parser.parse("(P(A) OR P(B))");

		s2 = parser.parse("(P(A) OR P(C))");



		result = unifier.unify(s1, s2);



		Assert.assertNull(result);



		s1 = parser.parse("(P(A) OR P(B))");

		s2 = parser.parse("(P(A) OR P(x))");



		result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(1, result.size());

		Assert.assertEquals(new Constant("B"), result.get(new Variable("x")));



		s1 = parser.parse("(P(A) => P(B))");

		s2 = parser.parse("(P(A) => P(B))");



		result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(0, result.size());



		s1 = parser.parse("(P(A) => P(B))");

		s2 = parser.parse("(P(A) => P(C))");



		result = unifier.unify(s1, s2);



		Assert.assertNull(result);



		s1 = parser.parse("(P(A) => P(B))");

		s2 = parser.parse("(P(A) => P(x))");



		result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(1, result.size());

		Assert.assertEquals(new Constant("B"), result.get(new Variable("x")));



		s1 = parser.parse("(P(A) <=> P(B))");

		s2 = parser.parse("(P(A) <=> P(B))");



		result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(0, result.size());



		s1 = parser.parse("(P(A) <=> P(B))");

		s2 = parser.parse("(P(A) <=> P(C))");



		result = unifier.unify(s1, s2);



		Assert.assertNull(result);



		s1 = parser.parse("(P(A) <=> P(B))");

		s2 = parser.parse("(P(A) <=> P(x))");



		result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(1, result.size());

		Assert.assertEquals(new Constant("B"), result.get(new Variable("x")));



		s1 = parser.parse("((P(A) AND P(B)) OR (P(C) => (P(A) <=> P(C))))");

		s2 = parser.parse("((P(A) AND P(B)) OR (P(C) => (P(A) <=> P(C))))");



		result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(0, result.size());



		s1 = parser.parse("((P(A) AND P(B)) OR (P(C) => (P(A) <=> P(C))))");

		s2 = parser.parse("((P(A) AND P(B)) OR (P(C) => (P(A) <=> P(A))))");



		result = unifier.unify(s1, s2);



		Assert.assertNull(result);



		s1 = parser.parse("((P(A) AND P(B)) OR (P(C) => (P(A) <=> P(C))))");

		s2 = parser.parse("((P(A) AND P(B)) OR (P(C) => (P(A) <=> P(x))))");



		result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(1, result.size());

		Assert.assertEquals(new Constant("C"), result.get(new Variable("x")));

	}



	@Test

	public void testQuantifiedSentence() {

		FOLDomain domain = new FOLDomain();

		domain.addConstant("A");

		domain.addConstant("B");

		domain.addConstant("C");

		domain.addFunction("Plus");

		domain.addPredicate("P");



		FOLParser parser = new FOLParser(domain);



		Sentence s1 = parser

				.parse("FORALL x,y ((P(x) AND P(A)) OR (P(A) => P(y)))");

		Sentence s2 = parser

				.parse("FORALL x,y ((P(x) AND P(A)) OR (P(A) => P(y)))");



		Map<Variable, Term> result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(0, result.size());



		s1 = parser.parse("FORALL x,y ((P(x) AND P(A)) OR (P(A) => P(y)))");

		s2 = parser.parse("FORALL x   ((P(x) AND P(A)) OR (P(A) => P(y)))");



		result = unifier.unify(s1, s2);



		Assert.assertNull(result);



		s1 = parser.parse("FORALL x,y ((P(x) AND P(A)) OR (P(A) => P(y)))");

		s2 = parser.parse("FORALL x,y ((P(x) AND P(A)) OR (P(B) => P(y)))");



		result = unifier.unify(s1, s2);



		Assert.assertNull(result);



		s1 = parser.parse("FORALL x,y ((P(x) AND P(A)) OR (P(A) => P(y)))");

		s2 = parser.parse("FORALL x,y ((P(A) AND P(A)) OR (P(A) => P(y)))");



		result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(1, result.size());

		Assert.assertEquals(new Constant("A"), result.get(new Variable("x")));



		//

		s1 = parser.parse("EXISTS x,y ((P(x) AND P(A)) OR (P(A) => P(y)))");

		s2 = parser.parse("EXISTS x,y ((P(x) AND P(A)) OR (P(A) => P(y)))");



		result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(0, result.size());



		s1 = parser.parse("EXISTS x,y ((P(x) AND P(A)) OR (P(A) => P(y)))");

		s2 = parser.parse("EXISTS x   ((P(x) AND P(A)) OR (P(A) => P(y)))");



		result = unifier.unify(s1, s2);



		Assert.assertNull(result);



		s1 = parser.parse("EXISTS x,y ((P(x) AND P(A)) OR (P(A) => P(y)))");

		s2 = parser.parse("EXISTS x,y ((P(x) AND P(A)) OR (P(B) => P(y)))");



		result = unifier.unify(s1, s2);



		Assert.assertNull(result);



		s1 = parser.parse("EXISTS x,y ((P(x) AND P(A)) OR (P(A) => P(y)))");

		s2 = parser.parse("EXISTS x,y ((P(A) AND P(A)) OR (P(A) => P(y)))");



		result = unifier.unify(s1, s2);



		Assert.assertNotNull(result);

		Assert.assertEquals(1, result.size());

		Assert.assertEquals(new Constant("A"), result.get(new Variable("x")));

	}

}