def test_problems_1(self): inp = """fof(a1, axiom, p(a) => q(a)). fof(a2, axiom, q(a) => $false). fof(a3, axiom, $true => p(a)). fof(c, conjecture, $false).""" result = [ problem.Problem( premises=[ problem.AnnotatedFormula( logic="fof", name="a1", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.PredicateExpression( predicate="p", arguments=[logic.Constant("a")]), operator=logic.BinaryConnective.IMPLICATION, right=logic.PredicateExpression( predicate="q", arguments=[logic.Constant("a")]), ), ), problem.AnnotatedFormula( logic="fof", name="a2", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.PredicateExpression( predicate="q", arguments=[logic.Constant("a")]), operator=logic.BinaryConnective.IMPLICATION, right=logic.DefinedConstant.FALSUM, ), ), problem.AnnotatedFormula( logic="fof", name="a3", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.DefinedConstant.VERUM, operator=logic.BinaryConnective.IMPLICATION, right=logic.PredicateExpression( predicate="p", arguments=[logic.Constant("a")]), ), ), ], conjecture=problem.AnnotatedFormula( logic="fof", name="c", role=problem.FormulaRole.CONJECTURE, formula=logic.DefinedConstant.FALSUM, ), ) ] self.check_parser(inp, result)
def visit_functor_term(self, obj, term_level=False, **kwargs): c0 = obj.children[0] is_defined = c0.startswith("$") if len(obj.children) > 1: if term_level: return logic.FunctorExpression( functor=c0, arguments=[ self.visit(c, term_level=term_level, **kwargs) for c in obj.children[1:] ], ) else: p = self._DEFINED_PREDICATE_MAP[c0] if is_defined else c0 return logic.PredicateExpression( predicate=p, arguments=[ self.visit(c, term_level=True, **kwargs) for c in obj.children[1:] ], ) else: assert len(obj.children) == 1 and isinstance(obj.children[0], str) if is_defined: if c0 == "$true": return logic.DefinedConstant.VERUM elif c0 == "$false": return logic.DefinedConstant.FALSUM else: return logic.DefinedConstant(c0) else: if c0[0] == "\"": return logic.DistinctObject(c0) else: return logic.Constant(c0)
def test_functor(self): inp = """cnf(and_definition1,axiom,( and(X,n0) = n0 )).""" result = problem.AnnotatedFormula( logic="cnf", name="and_definition1", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.FunctorExpression( functor="and", arguments=[logic.Variable("X"), logic.Constant("n0")]), operator=logic.BinaryConnective.EQ, right=logic.Constant("n0"), ), ) self.check_parser(inp, result)
def parseJavaToPython(node): if node.getVisitName() == "quantifier": return logic.Quantifier(node.getId()) elif node.getVisitName() == "binary_connective": return logic.BinaryConnective(node.getId()) elif node.getVisitName() == "defined_predicate": return logic.DefinedPredicate(node.getId()) elif node.getVisitName() == "unary_connective": return logic.UnaryConnective(node.getId()) elif node.getVisitName() == "unary_formula": return logic.UnaryFormula( OWLParser.parseJavaToPython(node.getConnective()), OWLParser.parseJavaToPython(node.getFormula())) elif node.getVisitName() == "quantified_formula": variables = [] for var in node.getVariables(): variables.append(OWLParser.parseJavaToPython(var)) return logic.QuantifiedFormula( OWLParser.parseJavaToPython(node.getQuantifier()), variables, OWLParser.parseJavaToPython(node.getFormula())) elif node.getVisitName() == "binary_formula": return logic.BinaryFormula( OWLParser.parseJavaToPython(node.getLeft()), OWLParser.parseJavaToPython(node.getOp()), OWLParser.parseJavaToPython(node.getRight())) elif node.getVisitName() == "predicate_expression": # TODO: find out how to handle lists like arguments arguments = [] for arg in node.getArguments(): arguments.append(OWLParser.parseJavaToPython(arg)) return logic.PredicateExpression(node.getPredicate(), arguments) elif node.getVisitName() == "typed_variable": return logic.TypedVariable( node.getName(), OWLParser.parseJavaToPython(node.getVType())) elif node.getVisitName() == "variable": return logic.Variable(node.getSymbol()) elif node.getVisitName() == "constant": return logic.Constant(node.getSymbol()) elif node.getVisitName() == "defined_constant": return logic.DefinedConstant(node.getId()) elif node.getVisitName() == "subtype": return logic.Subtype(OWLParser.parseJavaToPython(node.getLeft), OWLParser.parseJavaToPython(node.getRight)) elif node.getVisitName() == "type": return logic.Type(node.getName())
def parse_constant(self, variable: dict): return logic.Constant(symbol=variable["symbol"])
def test_problems_2_2(self): inp = """fof(a1, axiom, $true => a=d). fof(a2, axiom, $true => p(g(f(a),b))). fof(a3, axiom, $true => f(d)=b). fof(a4, axiom, $true => g(b,b)=c). fof(a5, axiom, p(c) => $false). fof(c, conjecture, $false).""" result = [ problem.Problem( premises=[ problem.AnnotatedFormula( logic="fof", name="a1", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.DefinedConstant.VERUM, operator=logic.BinaryConnective.IMPLICATION, right=logic.BinaryFormula( left=logic.Constant("a"), operator=logic.BinaryConnective.EQ, right=logic.Constant("d")), ), ), problem.AnnotatedFormula( logic="fof", name="a2", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.DefinedConstant.VERUM, operator=logic.BinaryConnective.IMPLICATION, right=logic.PredicateExpression( predicate="p", arguments=[ logic.FunctorExpression( functor="g", arguments=[ logic.FunctorExpression( functor="f", arguments=[ logic.Constant("a") ]), logic.Constant("b") ]), ]), ), ), problem.AnnotatedFormula( logic="fof", name="a3", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.DefinedConstant.VERUM, operator=logic.BinaryConnective.IMPLICATION, right=logic.BinaryFormula( left=logic.FunctorExpression( functor="f", arguments=[logic.Constant("d")]), operator=logic.BinaryConnective.EQ, right=logic.Constant("b")), ), ), problem.AnnotatedFormula( logic="fof", name="a4", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.DefinedConstant.VERUM, operator=logic.BinaryConnective.IMPLICATION, right=logic.BinaryFormula( left=logic.FunctorExpression( functor="g", arguments=[ logic.Constant("b"), logic.Constant("b") ]), operator=logic.BinaryConnective.EQ, right=logic.Constant("c")), ), ), problem.AnnotatedFormula( logic="fof", name="a5", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.PredicateExpression( predicate="p", arguments=[logic.Constant("c")]), operator=logic.BinaryConnective.IMPLICATION, right=logic.DefinedConstant.FALSUM, ), ), ], conjecture=problem.AnnotatedFormula( logic="fof", name="c", role=problem.FormulaRole.CONJECTURE, formula=logic.DefinedConstant.FALSUM, ), ) ] self.check_parser(inp, result)
def test_single_quote(self): inp = "p('This is arbitrary text')" result = logic.PredicateExpression( "p", [logic.Constant("'This is arbitrary text'")]) return inp, result
def test_problems_2_1(self): inp = """fof(a1, axiom, (p(e) & p(b) & p(d)) => $false). fof(a2, axiom, p(e) => p(d)). fof(a3, axiom, $true => p(f)). fof(a4, axiom, p(a) => $false). fof(a5, axiom, p(c) => p(e)). fof(a6, axiom, $true => p(c)). fof(a7, axiom, $true => (f=b)). fof(c, conjecture, $false).""" result = [ problem.Problem( premises=[ problem.AnnotatedFormula( logic="fof", name="a1", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.BinaryFormula( left=logic.PredicateExpression( predicate="p", arguments=[logic.Constant("e")]), operator=logic.BinaryConnective.CONJUNCTION, right=logic.BinaryFormula( left=logic.PredicateExpression( predicate="p", arguments=[logic.Constant("b")]), operator=logic.BinaryConnective. CONJUNCTION, right=logic.PredicateExpression( predicate="p", arguments=[logic.Constant("d")]), ), ), operator=logic.BinaryConnective.IMPLICATION, right=logic.DefinedConstant.FALSUM, ), ), problem.AnnotatedFormula( logic="fof", name="a2", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.PredicateExpression( predicate="p", arguments=[logic.Constant("e")]), operator=logic.BinaryConnective.IMPLICATION, right=logic.PredicateExpression( predicate="p", arguments=[logic.Constant("d")]), ), ), problem.AnnotatedFormula( logic="fof", name="a3", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.DefinedConstant.VERUM, operator=logic.BinaryConnective.IMPLICATION, right=logic.PredicateExpression( predicate="p", arguments=[logic.Constant("f")]), ), ), problem.AnnotatedFormula( logic="fof", name="a4", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.PredicateExpression( predicate="p", arguments=[logic.Constant("a")]), operator=logic.BinaryConnective.IMPLICATION, right=logic.DefinedConstant.FALSUM, ), ), problem.AnnotatedFormula( logic="fof", name="a5", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.PredicateExpression( predicate="p", arguments=[logic.Constant("c")]), operator=logic.BinaryConnective.IMPLICATION, right=logic.PredicateExpression( predicate="p", arguments=[logic.Constant("e")]), ), ), problem.AnnotatedFormula( logic="fof", name="a6", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.DefinedConstant.VERUM, operator=logic.BinaryConnective.IMPLICATION, right=logic.PredicateExpression( predicate="p", arguments=[logic.Constant("c")]), ), ), problem.AnnotatedFormula( logic="fof", name="a7", role=problem.FormulaRole.AXIOM, formula=logic.BinaryFormula( left=logic.DefinedConstant.VERUM, operator=logic.BinaryConnective.IMPLICATION, right=logic.BinaryFormula( left=logic.Constant("f"), operator=logic.BinaryConnective.EQ, right=logic.Constant("b")), ), ), ], conjecture=problem.AnnotatedFormula( logic="fof", name="c", role=problem.FormulaRole.CONJECTURE, formula=logic.DefinedConstant.FALSUM, ), ) ] self.check_parser(inp, result)