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 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 test_quantifier(self): inp = "![X1,X2]:?[Y1,Y2]:p(X1,X2,Y1,Y2)" result = logic.QuantifiedFormula( logic.Quantifier.UNIVERSAL, [logic.Variable("X1"), logic.Variable("X2")], logic.QuantifiedFormula( logic.Quantifier.EXISTENTIAL, [logic.Variable("Y1"), logic.Variable("Y2")], logic.PredicateExpression( "p", [ logic.Variable("X1"), logic.Variable("X2"), logic.Variable("Y1"), logic.Variable("Y2"), ], ), ), ) return inp, result
def test_verum(self): inp = """fof(mElmSort,axiom,( ! [W0] : ( aElement0(W0) => $true ) )).""" result = problem.AnnotatedFormula( logic="fof", name="mElmSort", role=problem.FormulaRole.AXIOM, formula=logic.QuantifiedFormula( quantifier=logic.Quantifier.UNIVERSAL, variables=[logic.Variable("W0")], formula=logic.BinaryFormula( left=logic.PredicateExpression( predicate="aElement0", arguments=[logic.Variable("W0")]), operator=logic.BinaryConnective.IMPLICATION, right=logic.DefinedConstant.VERUM, ), ), ) self.check_parser(inp, result)
def parse_predicate_expression(self, expression: dict) -> logic.PredicateExpression: return logic.PredicateExpression( predicate=self._parse_rec(expression["functor"]), arguments=[self._parse_rec(a) for a in expression["arguments"]], )
def test_double_quote(self): inp = 'p("This is arbitrary text")' result = logic.PredicateExpression( "p", [logic.DistinctObject('"This is arbitrary text"')]) return inp, result
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)