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

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

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

View Full Code Here

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

View Full Code Here

    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

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

View Full Code Here

    domain.addConstant("Some");
    domain.addConstant("Full");
    domain.addConstant("French");
    domain.addConstant("Thai");
    domain.addConstant("Burger");
    FOLParser parser = new FOLParser(domain);


    String c1 = "patrons(v,Some)";
    String c2 = "patrons(v,Full) AND (hungry(v) AND type(v,French))";
    String c3 = "patrons(v,Full) AND (hungry(v) AND (type(v,Thai) AND fri_sat(v)))";
    String c4 = "patrons(v,Full) AND (hungry(v) AND type(v,Burger))";
    String sh = "FORALL v (will_wait(v) <=> (" + c1 + " OR (" + c2
        + " OR (" + c3 + " OR (" + c4 + ")))))";


    Sentence s = parser.parse(sh);


    CNFConverter cnfConv = new CNFConverter(parser);


    CNF cnf = cnfConv.convertToCNF(s);


    // Contains 9 duplicates
    Assert.assertEquals(40, cnf.getNumberOfClauses());


    Set<Clause> clauses = new HashSet<Clause>(cnf.getConjunctionOfClauses());


    // duplicates removed
    Assert.assertEquals(31, clauses.size());


    clauses.removeAll(SubsumptionElimination.findSubsumedClauses(clauses));


    // subsumed clauses removed
    Assert.assertEquals(8, clauses.size());


    // Ensure only the 8 correct/expected clauses remain
    Clause cl1 = cnfConv
        .convertToCNF(
            parser.parse("(NOT(will_wait(v)) OR (patrons(v,Full) OR patrons(v,Some)))"))
        .getConjunctionOfClauses().get(0);
    Clause cl2 = cnfConv
        .convertToCNF(
            parser.parse("(NOT(will_wait(v)) OR (hungry(v) OR patrons(v,Some)))"))
        .getConjunctionOfClauses().get(0);
    Clause cl3 = cnfConv
        .convertToCNF(
            parser.parse("(NOT(will_wait(v)) OR (patrons(v,Some) OR (type(v,Burger) OR (type(v,French) OR type(v,Thai)))))"))
        .getConjunctionOfClauses().get(0);
    Clause cl4 = cnfConv
        .convertToCNF(
            parser.parse("(NOT(will_wait(v)) OR (fri_sat(v) OR (patrons(v,Some) OR (type(v,Burger) OR type(v,French)))))"))
        .getConjunctionOfClauses().get(0);
    Clause cl5 = cnfConv
        .convertToCNF(
            parser.parse("(NOT(patrons(v,Some)) OR will_wait(v))"))
        .getConjunctionOfClauses().get(0);
    Clause cl6 = cnfConv
        .convertToCNF(
            parser.parse("(NOT(hungry(v)) OR (NOT(patrons(v,Full)) OR (NOT(type(v,French)) OR will_wait(v))))"))
        .getConjunctionOfClauses().get(0);
    Clause cl7 = cnfConv
        .convertToCNF(
            parser.parse("(NOT(fri_sat(v)) OR (NOT(hungry(v)) OR (NOT(patrons(v,Full)) OR (NOT(type(v,Thai)) OR will_wait(v)))))"))
        .getConjunctionOfClauses().get(0);
    Clause cl8 = cnfConv
        .convertToCNF(
            parser.parse("(NOT(hungry(v)) OR (NOT(patrons(v,Full)) OR (NOT(type(v,Burger)) OR will_wait(v))))"))
        .getConjunctionOfClauses().get(0);


    Assert.assertTrue(clauses.contains(cl1));
    Assert.assertTrue(clauses.contains(cl2));
    Assert.assertTrue(clauses.contains(cl3));

View Full Code Here


  VariableCollector vc;


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

View Full Code Here

public class CNFConverterTest {


  @Test
  public void testExamplePg295AIMA2e() {
    FOLDomain domain = DomainFactory.weaponsDomain();
    FOLParser parser = new FOLParser(domain);


    Sentence origSentence = parser
        .parse("FORALL x ((((American(x) AND Weapon(y)) AND Sells(x, y, z)) AND Hostile(z)) => Criminal(x))");


    CNFConverter cnfConv = new CNFConverter(parser);


    CNF cnf = cnfConv.convertToCNF(origSentence);

View Full Code Here

  }


  @Test
  public void testExamplePg296AIMA2e() {
    FOLDomain domain = DomainFactory.lovesAnimalDomain();
    FOLParser parser = new FOLParser(domain);


    Sentence origSentence = parser
        .parse("FORALL x (FORALL y (Animal(y) => Loves(x, y)) => EXISTS y Loves(y, x))");


    CNFConverter cnfConv = new CNFConverter(parser);


    CNF cnf = cnfConv.convertToCNF(origSentence);

View Full Code Here

  }


  @Test
  public void testExamplesPg299AIMA2e() {
    FOLDomain domain = DomainFactory.lovesAnimalDomain();
    FOLParser parser = new FOLParser(domain);


    // FOL A.
    Sentence origSentence = parser
        .parse("FORALL x (FORALL y (Animal(y) => Loves(x, y)) => EXISTS y Loves(y, x))");


    CNFConverter cnfConv = new CNFConverter(parser);


    CNF cnf = cnfConv.convertToCNF(origSentence);


    // CNF A1. and A2.
    Assert.assertEquals(
        "[Animal(SF0(x)), Loves(SF1(x),x)],[~Loves(x,SF0(x)), Loves(SF1(x),x)]",
        cnf.toString());


    // FOL B.
    origSentence = parser
        .parse("FORALL x (EXISTS y (Animal(y) AND Kills(x, y)) => FORALL z NOT(Loves(z, x)))");


    cnf = cnfConv.convertToCNF(origSentence);


    // CNF B.
    Assert.assertEquals("[~Animal(y), ~Kills(x,y), ~Loves(z,x)]",
        cnf.toString());


    // FOL C.
    origSentence = parser.parse("FORALL x (Animal(x) => Loves(Jack, x))");


    cnf = cnfConv.convertToCNF(origSentence);


    // CNF C.
    Assert.assertEquals("[~Animal(x), Loves(Jack,x)]", cnf.toString());


    // FOL D.
    origSentence = parser
        .parse("(Kills(Jack, Tuna) OR Kills(Curiosity, Tuna))");


    cnf = cnfConv.convertToCNF(origSentence);


    // CNF D.
    Assert.assertEquals("[Kills(Curiosity,Tuna), Kills(Jack,Tuna)]",
        cnf.toString());


    // FOL E.
    origSentence = parser.parse("Cat(Tuna)");


    cnf = cnfConv.convertToCNF(origSentence);


    // CNF E.
    Assert.assertEquals("[Cat(Tuna)]", cnf.toString());


    // FOL F.
    origSentence = parser.parse("FORALL x (Cat(x) => Animal(x))");


    cnf = cnfConv.convertToCNF(origSentence);


    // CNF F.
    Assert.assertEquals("[~Cat(x), Animal(x)]", cnf.toString());


    // FOL G.
    origSentence = parser.parse("NOT(Kills(Curiosity, Tuna))");


    cnf = cnfConv.convertToCNF(origSentence);


    // CNF G.
    Assert.assertEquals("[~Kills(Curiosity,Tuna)]", cnf.toString());

View Full Code Here

    FOLDomain domain = new FOLDomain();
    domain.addPredicate("P");
    domain.addPredicate("R");
    domain.addPredicate("Q");


    FOLParser parser = new FOLParser(domain);


    Sentence origSentence = parser
        .parse("EXISTS w (FORALL x ( (EXISTS z (Q(w, z))) => (EXISTS y (NOT(P(x, y)) AND R(y))) ) )");


    CNFConverter cnfConv = new CNFConverter(parser);


    CNF cnf = cnfConv.convertToCNF(origSentence);


    Assert.assertEquals("[~P(x,SF0(x)), ~Q(SC0,z)],[~Q(SC0,z), R(SF0(x))]",
        cnf.toString());


    // Ax.Ay.(p(x,y) => Ez.(q(x,y,z)))
    origSentence = parser
        .parse("FORALL x1 (FORALL y1 (P(x1, y1) => EXISTS z1 (Q(x1, y1, z1))))");


    cnf = cnfConv.convertToCNF(origSentence);


    Assert.assertEquals("[~P(x1,y1), Q(x1,y1,SF1(x1,y1))]", cnf.toString());


    // Ex.Ay.Az.(r(y,z) <=> q(x,y,z))
    origSentence = parser
        .parse("EXISTS x2 (FORALL y2 (FORALL z2 (R(y2, z2) <=> Q(x2, y2, z2))))");


    cnf = cnfConv.convertToCNF(origSentence);


    Assert.assertEquals(
        "[~R(y2,z2), Q(SC1,y2,z2)],[~Q(SC1,y2,z2), R(y2,z2)]",
        cnf.toString());


    // Ax.Ey.(~p(x,y) => Az.(q(x,y,z)))
    origSentence = parser
        .parse("FORALL x3 (EXISTS y3 (NOT(P(x3, y3)) => FORALL z3 (Q(x3, y3, z3))))");


    cnf = cnfConv.convertToCNF(origSentence);


    Assert.assertEquals("[P(x3,SF2(x3)), Q(x3,SF2(x3),z3)]", cnf.toString());


    // Ew.Ex.Ey.Ez.(r(x,y) & q(x,w,z))
    origSentence = parser
        .parse("NOT(EXISTS w4 (EXISTS x4 (EXISTS y4 ( EXISTS z4 (R(x4, y4) AND Q(x4, w4, z4))))))");


    cnf = cnfConv.convertToCNF(origSentence);


    Assert.assertEquals("[~Q(x4,w4,z4), ~R(x4,y4)]", cnf.toString());

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.