Examples of aima.core.logic.fol.parsing.FOLParser

aima.core.logic.fol.parsing.FOLParser
@author Ravi Mohan

    this(domain, inferenceProcedure, new Unifier());
  }


  public FOLKnowledgeBase(FOLDomain domain,
      InferenceProcedure inferenceProcedure, Unifier unifier) {
    this.parser = new FOLParser(new FOLDomain(domain));
    this.inferenceProcedure = inferenceProcedure;
    this.unifier = unifier;
    //
    this.substVisitor = new SubstVisitor();
    this.variableCollector = new VariableCollector();

View Full Code Here

  @Before
  public void setUp() {
    FOLDomain domain = DomainFactory.crusadesDomain();


    lexer = new FOLLexer(domain);
    parser = new FOLParser(lexer);
  }

View Full Code Here

    Assert.assertEquals(3, ((Function) f).getTerms().size());
  }


  @Test
  public void testConnectedImplication() {
    parser = new FOLParser(DomainFactory.weaponsDomain());
    parser.parse("((Missile(m) AND Owns(Nono,m)) => Sells(West , m ,Nono))");
  }

View Full Code Here

  public void testEqualityBinaryResolvents() {
    FOLDomain domain = new FOLDomain();
    domain.addConstant("A");
    domain.addConstant("B");


    FOLParser parser = new FOLParser(domain);


    // B = A
    Clause c1 = new Clause();
    c1.addPositiveLiteral((AtomicSentence) parser.parse("B = A"));


    Clause c2 = new Clause();
    c2.addNegativeLiteral((AtomicSentence) parser.parse("B = A"));
    c2.addPositiveLiteral((AtomicSentence) parser.parse("B = A"));


    Set<Clause> resolvents = c1.binaryResolvents(c2);


    Assert.assertEquals(1, resolvents.size());
    Assert.assertEquals("[[B = A]]", resolvents.toString());

View Full Code Here

    domain.addPredicate("Animal");
    domain.addPredicate("Kills");
    domain.addFunction("F");
    domain.addFunction("SF0");


    FOLParser parser = new FOLParser(domain);


    CNFConverter cnfConverter = new CNFConverter(parser);
    Sentence s1 = parser.parse("((x1 = y1 AND y1 = z1) => x1 = z1)");
    Sentence s2 = parser.parse("((x2 = y2 AND F(y2) = z2) => F(x2) = z2)");
    CNF cnf1 = cnfConverter.convertToCNF(s1);
    CNF cnf2 = cnfConverter.convertToCNF(s2);


    Clause c1 = cnf1.getConjunctionOfClauses().get(0);
    Clause c2 = cnf2.getConjunctionOfClauses().get(0);


    Assert.assertFalse(c1.equals(c2));


    s1 = parser.parse("((x1 = y1 AND y1 = z1) => x1 = z1)");
    s2 = parser.parse("((x2 = y2 AND y2 = z2) => x2 = z2)");
    cnf1 = cnfConverter.convertToCNF(s1);
    cnf2 = cnfConverter.convertToCNF(s2);


    c1 = cnf1.getConjunctionOfClauses().get(0);
    c2 = cnf2.getConjunctionOfClauses().get(0);


    Assert.assertTrue(c1.equals(c2));


    s1 = parser.parse("((x1 = y1 AND y1 = z1) => x1 = z1)");
    s2 = parser.parse("((y2 = z2 AND x2 = y2) => x2 = z2)");
    cnf1 = cnfConverter.convertToCNF(s1);
    cnf2 = cnfConverter.convertToCNF(s2);


    c1 = cnf1.getConjunctionOfClauses().get(0);
    c2 = cnf2.getConjunctionOfClauses().get(0);


    Assert.assertTrue(c1.equals(c2));


    s1 = parser.parse("(((x1 = y1 AND y1 = z1) AND z1 = r1) => x1 = r1)");
    s2 = parser.parse("(((x2 = y2 AND y2 = z2) AND z2 = r2) => x2 = r2)");
    cnf1 = cnfConverter.convertToCNF(s1);
    cnf2 = cnfConverter.convertToCNF(s2);


    c1 = cnf1.getConjunctionOfClauses().get(0);
    c2 = cnf2.getConjunctionOfClauses().get(0);


    Assert.assertTrue(c1.equals(c2));


    s1 = parser.parse("(((x1 = y1 AND y1 = z1) AND z1 = r1) => x1 = r1)");
    s2 = parser.parse("(((z2 = r2 AND y2 = z2) AND x2 = y2) => x2 = r2)");
    cnf1 = cnfConverter.convertToCNF(s1);
    cnf2 = cnfConverter.convertToCNF(s2);


    c1 = cnf1.getConjunctionOfClauses().get(0);
    c2 = cnf2.getConjunctionOfClauses().get(0);


    Assert.assertTrue(c1.equals(c2));


    s1 = parser.parse("(((x1 = y1 AND y1 = z1) AND z1 = r1) => x1 = r1)");
    s2 = parser.parse("(((x2 = y2 AND y2 = z2) AND z2 = y2) => x2 = r2)");
    cnf1 = cnfConverter.convertToCNF(s1);
    cnf2 = cnfConverter.convertToCNF(s2);


    c1 = cnf1.getConjunctionOfClauses().get(0);
    c2 = cnf2.getConjunctionOfClauses().get(0);


    Assert.assertFalse(c1.equals(c2));


    s1 = parser
        .parse("(((((x1 = y1 AND y1 = z1) AND z1 = r1) AND r1 = q1) AND q1 = s1) => x1 = r1)");
    s2 = parser
        .parse("(((((x2 = y2 AND y2 = z2) AND z2 = r2) AND r2 = q2) AND q2 = s2) => x2 = r2)");
    cnf1 = cnfConverter.convertToCNF(s1);
    cnf2 = cnfConverter.convertToCNF(s2);


    c1 = cnf1.getConjunctionOfClauses().get(0);
    c2 = cnf2.getConjunctionOfClauses().get(0);


    Assert.assertTrue(c1.equals(c2));


    s1 = parser
        .parse("((((NOT(Animal(c1920)) OR NOT(Animal(c1921))) OR NOT(Kills(c1922,c1920))) OR NOT(Kills(c1919,c1921))) OR NOT(Kills(SF0(c1922),SF0(c1919))))");
    s2 = parser
        .parse("((((NOT(Animal(c1929)) OR NOT(Animal(c1928))) OR NOT(Kills(c1927,c1929))) OR NOT(Kills(c1930,c1928))) OR NOT(Kills(SF0(c1930),SF0(c1927))))");
    cnf1 = cnfConverter.convertToCNF(s1);
    cnf2 = cnfConverter.convertToCNF(s2);


    c1 = cnf1.getConjunctionOfClauses().get(0);

View Full Code Here

    domain.addFunction("G");
    domain.addFunction("H");
    domain.addPredicate("P");
    domain.addPredicate("Q");


    FOLParser parser = new FOLParser(domain);


    // p(x,y), q(a,b), p(b,a), q(y,x)
    Clause c = new Clause();
    c.addPositiveLiteral((Predicate) parser.parse("P(x,y)"));
    c.addPositiveLiteral((Predicate) parser.parse("Q(A,B)"));
    c.addNegativeLiteral((Predicate) parser.parse("P(B,A)"));
    c.addPositiveLiteral((Predicate) parser.parse("Q(y,x)"));


    Assert.assertEquals("[[~P(B,A), P(B,A), Q(A,B)]]", c
        .getNonTrivialFactors().toString());


    // p(x,y), q(a,b), p(b,a), q(y,x)
    c = new Clause();
    c.addPositiveLiteral((Predicate) parser.parse("P(x,y)"));
    c.addPositiveLiteral((Predicate) parser.parse("Q(A,B)"));
    c.addNegativeLiteral((Predicate) parser.parse("P(B,A)"));
    c.addNegativeLiteral((Predicate) parser.parse("Q(y,x)"));


    Assert.assertEquals("[]", c.getNonTrivialFactors().toString());


    // p(x,f(y)), p(g(u),x), p(f(y),u)
    c = new Clause();
    c.addPositiveLiteral((Predicate) parser.parse("P(x,F(y))"));
    c.addPositiveLiteral((Predicate) parser.parse("P(G(u),x)"));
    c.addPositiveLiteral((Predicate) parser.parse("P(F(y),u)"));


    // Should be: [{P(F(c#),F(c#)),P(G(F(c#)),F(c#))}]
    c = c.getNonTrivialFactors().iterator().next();
    Literal p = c.getPositiveLiterals().get(0);
    Assert.assertEquals("P", p.getAtomicSentence().getSymbolicName());
    Function f = (Function) p.getAtomicSentence().getArgs().get(0);
    Assert.assertEquals("F", f.getFunctionName());
    Variable v = (Variable) f.getTerms().get(0);
    f = (Function) p.getAtomicSentence().getArgs().get(1);
    Assert.assertEquals("F", f.getFunctionName());
    Assert.assertEquals(v, f.getTerms().get(0));


    //
    p = c.getPositiveLiterals().get(1);
    f = (Function) p.getAtomicSentence().getArgs().get(0);
    Assert.assertEquals("G", f.getFunctionName());
    f = (Function) f.getTerms().get(0);
    Assert.assertEquals("F", f.getFunctionName());
    Assert.assertEquals(v, f.getTerms().get(0));
    f = (Function) p.getAtomicSentence().getArgs().get(1);
    Assert.assertEquals("F", f.getFunctionName());
    Assert.assertEquals(v, f.getTerms().get(0));


    // p(g(x)), q(x), p(f(a)), p(x), p(g(f(x))), q(f(a))
    c = new Clause();
    c.addPositiveLiteral((Predicate) parser.parse("P(G(x))"));
    c.addPositiveLiteral((Predicate) parser.parse("Q(x)"));
    c.addPositiveLiteral((Predicate) parser.parse("P(F(A))"));
    c.addPositiveLiteral((Predicate) parser.parse("P(x)"));
    c.addPositiveLiteral((Predicate) parser.parse("P(G(F(x)))"));
    c.addPositiveLiteral((Predicate) parser.parse("Q(F(A))"));


    Assert.assertEquals("[[P(F(A)), P(G(F(F(A)))), P(G(F(A))), Q(F(A))]]",
        c.getNonTrivialFactors().toString());
  }

View Full Code Here

    domain.addPredicate("P");
    domain.addPredicate("Q");
    domain.addPredicate("R");
    domain.addFunction("F");


    FOLParser parser = new FOLParser(domain);


    // {p(f(a)),~p(f(a))}
    Clause c = new Clause();
    c.addPositiveLiteral((Predicate) parser.parse("P(F(A))"));
    Assert.assertFalse(c.isTautology());
    c.addNegativeLiteral((Predicate) parser.parse("P(F(A))"));
    Assert.assertTrue(c.isTautology());


    // {p(x),q(y),~q(y),r(z)}
    c = new Clause();
    c.addPositiveLiteral((Predicate) parser.parse("P(x)"));
    Assert.assertFalse(c.isTautology());
    c.addPositiveLiteral((Predicate) parser.parse("Q(y)"));
    Assert.assertFalse(c.isTautology());
    c.addNegativeLiteral((Predicate) parser.parse("Q(y)"));
    Assert.assertTrue(c.isTautology());
    c.addPositiveLiteral((Predicate) parser.parse("R(z)"));
    Assert.assertTrue(c.isTautology());


    // {~p(a),p(x)}
    c = new Clause();
    c.addNegativeLiteral((Predicate) parser.parse("P(A)"));
    Assert.assertFalse(c.isTautology());
    c.addPositiveLiteral((Predicate) parser.parse("P(x)"));
    Assert.assertFalse(c.isTautology());
  }

View Full Code Here

    domain.addConstant("I");
    domain.addConstant("J");
    domain.addPredicate("P");
    domain.addPredicate("Q");


    FOLParser parser = new FOLParser(domain);


    // Example
    // {~p(a,b),q(c)}
    Clause psi = new Clause();
    psi.addNegativeLiteral((Predicate) parser.parse("P(A,B)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(C)"));
    // {~p(x,y)}
    Clause phi = new Clause();
    phi.addNegativeLiteral((Predicate) parser.parse("P(x,y)"));


    Assert.assertTrue(phi.subsumes(psi));
    // Non-Example
    // {~p(x,b),q(x)}
    psi = new Clause();
    psi.addNegativeLiteral((Predicate) parser.parse("P(x,B)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(x)"));
    // {~p(a,y)}
    phi = new Clause();
    phi.addNegativeLiteral((Predicate) parser.parse("P(A,y)"));
    // Reason for Non-Example:
    // {p(b,b)}
    // {~q(b)}
    Assert.assertFalse(phi.subsumes(psi));


    //
    // Additional Examples


    // Non-Example
    // {~p(x,b),q(z)}
    psi = new Clause();
    psi.addNegativeLiteral((Predicate) parser.parse("P(x,B)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(z)"));
    // {~p(a,y)}
    phi = new Clause();
    phi.addNegativeLiteral((Predicate) parser.parse("P(A,y)"));


    Assert.assertFalse(phi.subsumes(psi));


    // Example
    // {~p(a,b),~p(w,z),q(c)}
    psi = new Clause();
    psi.addNegativeLiteral((Predicate) parser.parse("P(A,B)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(w,z)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(C)"));
    // {~p(x,y),~p(a,b)}
    phi = new Clause();
    phi.addNegativeLiteral((Predicate) parser.parse("P(x,y)"));
    phi.addNegativeLiteral((Predicate) parser.parse("P(A,B)"));


    Assert.assertTrue(phi.subsumes(psi));


    // Non-Example
    // {~p(v,b),~p(w,z),q(c)}
    psi = new Clause();
    psi.addNegativeLiteral((Predicate) parser.parse("P(v,B)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(w,z)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(C)"));
    // {~p(x,y),~p(a,b)}
    phi = new Clause();
    phi.addNegativeLiteral((Predicate) parser.parse("P(x,y)"));
    phi.addNegativeLiteral((Predicate) parser.parse("P(A,B)"));


    Assert.assertFalse(phi.subsumes(psi));


    // Example
    // {~p(a,b),~p(c,d),~p(e,f),~p(g,h),~p(i,j),q(c)}
    psi = new Clause();
    psi.addNegativeLiteral((Predicate) parser.parse("P(A,B)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(C,D)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(E,F)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(G,H)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(I,J)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(C)"));
    // {~p(i,j)}
    phi = new Clause();
    phi.addNegativeLiteral((Predicate) parser.parse("P(I,J)"));


    Assert.assertTrue(phi.subsumes(psi));


    // Example
    // {~p(a,b),~p(c,d),~p(e,f),q(c)}
    psi = new Clause();
    psi.addNegativeLiteral((Predicate) parser.parse("P(A,B)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(C,D)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(E,F)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(C)"));
    // {~p(e,f),~p(a,b),~p(c,d)}
    phi = new Clause();
    phi.addNegativeLiteral((Predicate) parser.parse("P(E,F)"));
    phi.addNegativeLiteral((Predicate) parser.parse("P(A,B)"));
    phi.addNegativeLiteral((Predicate) parser.parse("P(C,D)"));


    Assert.assertTrue(phi.subsumes(psi));


    // Example
    // {~p(a,b),~p(c,d),~p(e,f),~p(g,h),~p(i,j),q(c)}
    psi = new Clause();
    psi.addNegativeLiteral((Predicate) parser.parse("P(A,B)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(C,D)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(E,F)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(G,H)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(I,J)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(C)"));
    // {~p(i,j),~p(c,d)}
    phi = new Clause();
    phi.addNegativeLiteral((Predicate) parser.parse("P(I,J)"));
    phi.addNegativeLiteral((Predicate) parser.parse("P(C,D)"));


    Assert.assertTrue(phi.subsumes(psi));


    // Non-Example
    // {~p(a,b),~p(x,d),~p(e,f),~p(g,h),~p(i,j),q(c)}
    psi = new Clause();
    psi.addNegativeLiteral((Predicate) parser.parse("P(A,B)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(x,D)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(E,F)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(G,H)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(I,J)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(C)"));
    // {~p(i,j),~p(c,d)}
    phi = new Clause();
    phi.addNegativeLiteral((Predicate) parser.parse("P(I,J)"));
    phi.addNegativeLiteral((Predicate) parser.parse("P(C,D)"));


    Assert.assertFalse(phi.subsumes(psi));


    // Example
    // {~p(a,b),~p(c,d),~p(e,f),~p(g,h),~p(i,j),q(c)}
    psi = new Clause();
    psi.addNegativeLiteral((Predicate) parser.parse("P(A,B)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(C,D)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(E,F)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(G,H)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(I,J)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(C)"));
    // {~p(i,j),~p(a,x)}
    phi = new Clause();
    phi.addNegativeLiteral((Predicate) parser.parse("P(I,J)"));
    phi.addNegativeLiteral((Predicate) parser.parse("P(A,x)"));


    Assert.assertTrue(phi.subsumes(psi));


    // Example
    // {~p(a,b),~p(c,d),~p(e,f),~p(g,h),~p(i,j),q(a,b),q(c,d),q(e,f)}
    psi = new Clause();
    psi.addNegativeLiteral((Predicate) parser.parse("P(A,B)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(C,D)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(E,F)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(G,H)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(I,J)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(A,B)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(C,D)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(E,F)"));
    // {~p(i,j),~p(a,b),q(e,f),q(a,b)}
    phi = new Clause();
    phi.addNegativeLiteral((Predicate) parser.parse("P(I,J)"));
    phi.addNegativeLiteral((Predicate) parser.parse("P(A,B)"));
    phi.addPositiveLiteral((Predicate) parser.parse("Q(E,F)"));
    phi.addPositiveLiteral((Predicate) parser.parse("Q(A,B)"));


    Assert.assertTrue(phi.subsumes(psi));


    // Non-Example
    // {~p(a,b),~p(c,d),~p(e,f),~p(g,h),~p(i,j),q(a,b),q(c,d),q(e,f)}
    psi = new Clause();
    psi.addNegativeLiteral((Predicate) parser.parse("P(A,B)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(C,D)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(E,F)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(G,H)"));
    psi.addNegativeLiteral((Predicate) parser.parse("P(I,J)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(A,B)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(C,D)"));
    psi.addPositiveLiteral((Predicate) parser.parse("Q(E,F)"));
    // {~p(i,j),~p(a,b),q(e,f),q(a,b)}
    phi = new Clause();
    phi.addNegativeLiteral((Predicate) parser.parse("P(I,J)"));
    phi.addNegativeLiteral((Predicate) parser.parse("P(A,B)"));
    phi.addPositiveLiteral((Predicate) parser.parse("Q(E,A)"));
    phi.addPositiveLiteral((Predicate) parser.parse("Q(A,B)"));


    Assert.assertFalse(phi.subsumes(psi));
  }

View Full Code Here

  FOLParser parser;


  @Before
  public void setUp() {
    collector = new PredicateCollector();
    parser = new FOLParser(DomainFactory.weaponsDomain());
  }

View Full Code Here

  private FOLParser parser;
  private SubstVisitor sv;


  @Before
  public void setUp() {
    parser = new FOLParser(DomainFactory.crusadesDomain());
    sv = new SubstVisitor();
  }

View Full Code Here

0 1 2 3 4

TOP

Related Classes of aima.core.logic.fol.parsing.FOLParser

aima.core.logic.common.Token

aima.core.logic.fol.kb.FOLKnowledgeBase

aima.core.logic.fol.parsing.ast.ConnectedSentence

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

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

aima.core.logic.fol.parsing.ast.NotSentence

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

aima.core.logic.fol.parsing.ast.QuantifiedSentence

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

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

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.