concepts.dsl.parsers.fol_python_parser.FOLPythonParser#

class FOLPythonParser[source]#

Bases: ParserBase

A parser to parse first-order logic (FOL) expressions in Python syntax. Currrently supported features:

logic operations: and, or, not
quantifiers: forall, exists (see below for the syntax)
function application: f(x, y, z)
function definition: def f(x, y, z): return x + y + z

The syntax for quantifiers is as follows:

from typing import Any, Type, Callable

def forall(dtype: Type, func: Callable[[Any], bool]) -> bool: ...
def exists(dtype: Type, func: Callable[[Any], bool]) -> bool: ...

Examples

from concepts.dsl.dsl_types import ObjectType
from concepts.dsl.function_domain import FunctionDomain

domain = FunctionDomain()
domain.define_type(ObjectType('Person'))

parser = FOLPythonParser(domain, inplace_definition=True)
parser.parse_expression('exists(Person, lambda x: is_phd(x))')

function_string = '''
def is_grandfather(x: Person, y: Person) -> bool:
    # x is the grandfather of y
    return exists(Person, lambda z: is_father(x, z) and is_parent(y, z))
'''
parser.parse_function(function_string)

Methods

`parse_domain_file`(path)	Parse a domain from a file.
`parse_domain_string`(string)	Parse a domain from a string.
`parse_expression`(string[, arguments])	Parse an expression from a string.
`parse_expression_ast`(expression[, arguments])
`parse_function`(string)

Attributes

`domain`	The domain for types and functions.
`inplace_definition`	Whether to allow functions to be defined in-place.

__init__(domain, inplace_definition=False, inplace_polymorphic_function=False, inplace_definition_type=False)[source]#

Initialize the parser.

Parameters:

domain (DSLDomainBase) – the domain to use.
inplace_definition (bool) – whether to allow expressions to contain functions that are not defined in the domain. If set to True, the parser will automatically define these functions.
inplace_polymorphic_function (bool) – whether inplace functions are assumed to be polymorphic.
inplace_definition_type (bool) – whether to allow expressions to contain types that are not defined in the domain. If set to True, the parser will automatically define these types.

__new__(**kwargs)#

parse_domain_file(path)#

Parse a domain from a file.

Parameters:: path (str) – the path to the file.
Returns:: the parsed domain.
Return type:: DSLDomainBase

parse_domain_string(string)[source]#

Parse a domain from a string.

Parameters:: string (str) – the string to parse.
Returns:: the parsed domain.
Return type:: DSLDomainBase

parse_expression(string, arguments=tuple())[source]#

Parse an expression from a string.

Parameters:

string (str) – the string to parse.
arguments (Sequence[Variable])

Returns:

the parsed expression.

Return type:

ValueOutputExpression

parse_expression_ast(expression, arguments=tuple())[source]#

Parameters:

expression (AST)
arguments (Sequence[Variable])

Return type:

ValueOutputExpression

parse_function(string)[source]#

Parameters:: string (str)
Return type:: Function

domain: DSLDomainBase#: The domain for types and functions.

inplace_definition: bool#: Whether to allow functions to be defined in-place.