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)
