AIMA.Test.Core.Unit.Logic.FOL.UnifierTest.testConnectedSentence C# (CSharp) Method

UnifierTest Class Documentation Mostrar archivo Open project: PaulMineau/AIMA.Net

testConnectedSentence() private method

private testConnectedSentence ( ) : void
return	void

        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))");

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

            Assert.IsNotNull(result);
            Assert.AreEqual(0, result.Count);

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

            result = unifier.unify(s1, s2);

            Assert.IsNull(result);

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

            result = unifier.unify(s1, s2);

            Assert.IsNotNull(result);
            Assert.AreEqual(1, result.Count);
            Assert.AreEqual(new Constant("B"), result[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.IsNotNull(result);
            Assert.AreEqual(0, result.Count);

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

            result = unifier.unify(s1, s2);

            Assert.IsNull(result);

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

            result = unifier.unify(s1, s2);

            Assert.IsNotNull(result);
            Assert.AreEqual(1, result.Count);
            Assert.AreEqual(new Constant("B"), result[new Variable("x")]);

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

            result = unifier.unify(s1, s2);

            Assert.IsNotNull(result);
            Assert.AreEqual(0, result.Count);

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

            result = unifier.unify(s1, s2);

            Assert.IsNull(result);

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

            result = unifier.unify(s1, s2);

            Assert.IsNotNull(result);
            Assert.AreEqual(1, result.Count);
            Assert.AreEqual(new Constant("B"), result[new Variable("x")]);

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

            result = unifier.unify(s1, s2);

            Assert.IsNotNull(result);
            Assert.AreEqual(0, result.Count);

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

            result = unifier.unify(s1, s2);

            Assert.IsNull(result);

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

            result = unifier.unify(s1, s2);

            Assert.IsNotNull(result);
            Assert.AreEqual(1, result.Count);
            Assert.AreEqual(new Constant("B"), result[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.IsNotNull(result);
            Assert.AreEqual(0, result.Count);

            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.IsNull(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.IsNotNull(result);
            Assert.AreEqual(1, result.Count);
            Assert.AreEqual(new Constant("C"), result[new Variable("x")]);
        }

UnifierTest

setUp

testAdditionalVariableMixtures

testCascadedOccursCheck

testConnectedSentence

testFailureIfThetaisNull

testKnows1

testKnows2

testKnows3

testKnows5

testNOTSentence

testQuantifiedSentence

testSimpleVariableUnification

testTermEquality

testThetaPassedBackIfXEqualsYBothVariables

testUnificationFailure

testVariableEqualsConstant