def expand(self, clause: typing.Union[Clause, Body, Procedure]) -> typing.Sequence[typing.Union[Body, Clause, Procedure]]:
"""
Expands the clause/byd/procedure by adding literals from the bottom clause
:param clause:
:param variable_lit_dependency:
:return:
"""
if isinstance(clause, (Body, Clause)):
return self._expand_clause(clause)
else:
clauses = clause.get_clauses()
# extend each clause individually
extensions = []
for cl_ind in range(len(clauses)):
clause_extensions = self._expand_clause(clauses[cl_ind])
for ext_cl_ind in range(len(clause_extensions)):
cls = [
clauses[x] if x != cl_ind else clause_extensions[ext_cl_ind]
for x in range(len(clauses))
]
if isinstance(clause, Disjunction):
extensions.append(Disjunction(cls))
else:
extensions.append(Recursion(cls))
return extensions
def variable_instantiation(
clause: typing.Union[Clause,Body,Procedure],
constant: Constant) -> typing.Sequence[typing.Union[Clause,Body,Procedure]]:
"""
Extends a clause by instantiation, replacing all occurrences
of a variable with a constant
"""
if isinstance(clause, (Clause, Body)):
return _instantiate_var_clause(clause, constant)
else:
clauses = clause.get_clauses()
# extend each clause individually
extensions = []
for cl_ind in range(len(clauses)):
clause_extensions = (_instantiate_var_clause(clauses[cl_ind], constant))
for ext_cl_ind in range(len(clause_extensions)):
cls = [
clauses[x] if x != cl_ind else clause_extensions[ext_cl_ind]
for x in range(len(clauses))
]
if isinstance(clause, Disjunction):
extensions.append(Disjunction(cls))
else:
extensions.append(Recursion(cls))
print("Extensions for {} are {}".format(clause,extensions))
return extensions
def plain_procedure_extension(self):
parent = c_pred("parent", 2)
ancestor = c_pred("ancestor", 2)
cl1 = ancestor("X", "Y") <= parent("X", "Y")
cl2 = ancestor("X", "Y") <= parent("X", "Z") & parent("Z", "Y")
proc = Disjunction([cl1, cl2])
extensions = plain_extension(proc, parent, connected_clauses=False)
assert len(extensions) == 25
def plain_extension(
clause: typing.Union[Clause, Body, Procedure],
predicate: Predicate,
connected_clauses: bool = True,
negated: bool = False,
) -> typing.Sequence[typing.Union[Clause, Body, Procedure]]:
"""
Extends a clause or a procedure without any bias. Only checks for variable type match.
Adds the predicate to the clause/procedure
"""
if isinstance(clause, (Clause, Body)):
if negated:
return _plain_extend_negation_clause(clause, predicate)
else:
return _plain_extend_clause(
clause, predicate, connected_clause=connected_clauses
)
else:
clauses = clause.get_clauses()
# extend each clause individually
extensions = []
for cl_ind in range(len(clauses)):
clause_extensions = (
_plain_extend_clause(
clauses[cl_ind], predicate, connected_clause=connected_clauses
)
if not negated
else _plain_extend_negation_clause(clauses[cl_ind], predicate)
)
for ext_cl_ind in range(len(clause_extensions)):
cls = [
clauses[x] if x != cl_ind else clause_extensions[ext_cl_ind]
for x in range(len(clauses))
]
if isinstance(clause, Disjunction):
extensions.append(Disjunction(cls))
else:
extensions.append(Recursion(cls))
return extensions