AbstractReasoner r = new BasicReasoner(kb_, new ArrayList<Implication>(), parser_ );

       

        //  Now see if we can get *all* answers

        GdlList questionList = parser_.parse("succ ?x ?y");

       

        List<GroundFact> answers = getAllAnswers( r,question);

        assertEquals( 3, answers.size() );

       

        assertEquals( new GroundFact(symbolTable_, "succ", "1", "2"), answers.get(0) );

       

        GdlList facts = parser_.parse("(true (cell 1 1 b))(true (cell 1 2 b))(true (cell 1 3 b))(true (cell 2 1 b))(true (cell 2 2 b))(true (cell 2 3 b))(true (cell 3 1 b))(true (cell 3 2 b))(true (cell 3 3 b))(true (control xplayer))");

        addFacts(facts);

       

        assertNull(f);

       

//        facts = parser_

//                .parse( "(true (cell 1 1 x)) (true (cell 1 2 o)) (true (cell 1 3 x)) (true (cell 2 1 o)) (true (cell 2 2 x)) (true (cell 2 2 x)) (true (cell 2 3 o)) (true (cell 3 1 b)) (true (cell 3 2 b)) (true (cell 3 3 b))" );

       

        // Get all next facts

        GroundFact does = GroundFact.fromExpression( parser_.parse("does xplayer noop") );

        GroundFact does2 = GroundFact.fromExpression( parser_.parse("does oplayer (mark 2 3)") );

       

        KnowledgeBase kb = new BasicKB();

       

        kb.setTrue(does);

        kb.setTrue(does2);

       

        AbstractReasoner r = new BasicReasoner(staticKb, info.getIndexedRules(), parser_);

       

       

       

        // Compute the initial state

        List<GroundFact> inits = r.getAllAnswers(initQuestion);

       

        KnowledgeBase currentState = new BasicKB();

        for (GroundFact move : moves) {

            kb.setTrue(move);

        }

       

       

        ProofContext context = new ProofContext(kb, parser_);

       

        List<GroundFact> nexts = r.getAllAnswers(nextQuestion, context);

       

        KnowledgeBase volatileKb = new BasicKB();

       

        AbstractReasoner reasoner = new BasicReasoner(staticKb, rules, parser_);

       

       

        ProofContext context = new ProofContext(volatileKb, parser_);

       

        List<GroundFact> init = reasoner.getAllAnswers( question, context );

       

        KnowledgeBase volatileKb = new BasicKB();

       

        AbstractReasoner reasoner = new BasicReasoner(staticKb, rules, parser_);

       

       

        ProofContext context = new ProofContext(volatileKb, parser_);

       

        List<GroundFact> init = reasoner.getAllAnswers( question, context );

       

    }

   

    public void testFunctionVarMapping()

    {

       

        TermFunction tf = getTermFunction("mark ?y ?z");

       

        TermVariable varX = getVariable("?x");

        TermVariable varY = getVariable("?y");

        TermVariable varZ = getVariable("?z");

       

        Substitution s = new Substitution();

        s.addMapping(varX, tf);

        s.addMapping(varY, getTermObject("1"));

        s.addMapping(varZ, getTermObject("2"));

       

       

       

        assertEquals( makeFact("legal (mark 1 2)"), result );

    }

    {

        String s1 = "count 1 1 ?var11583106 ?var11583106";

        String s2 = "count 1 1 ?var11580908 ?var11580909";

       

       

        // Make sure f1 can't map to f2

        assertFalse(f1.canMapVariables(f2));

       

        // But, that f2 can map to f1

    }

    {

        // First element is the IMPLIEDBY token; ignore it.

        // Second element is the head of the rule. It's a relation (fact).

       

        // Everything thereafter are the antecedent relations.

        Expression [] conjuncts = new Expression[rule.getArity()-1];

       

        // Create the conjunct list