def std_unification_solver(theory, syn_ctx, synth_funs, grammar_map, specification, verifier):
if len(synth_funs) > 1:
raise UnsuitableSolverException("DT Unification Solver: Multi-function unification not supported")
if specification.is_multipoint:
raise UnsuitableSolverException("Multi point specification")
synth_fun = synth_funs[0]
grammar = grammar_map[synth_fun]
decomposed_grammar = grammar.decompose(syn_ctx.macro_instantiator)
if decomposed_grammar == None:
raise UnsuitableSolverException("DT Unification Solver: Unable to decompose grammar")
term_grammar, pred_grammar, reverse_mapping = decomposed_grammar
generator_factory = enumerators.PointDistinctGeneratorFactory(specification)
term_generator = term_grammar.to_generator(generator_factory)
pred_generator = pred_grammar.to_generator(generator_factory)
solver = solvers.Solver(syn_ctx)
term_solver = termsolvers.PointDistinctTermSolver(specification.term_signature, term_generator)
unifier = unifiers.PointDistinctDTUnifier(pred_generator, term_solver, synth_fun, syn_ctx)
solver = solvers.Solver(syn_ctx)
solutions = solver.solve(
generator_factory,
term_solver,
unifier,
verifier,
verify_term_solve=True
)
solution = next(solutions)
final_solution = rewrite_solution([synth_fun], solution, reverse_mapping)
return final_solution
def std_unification_solver(theory,
syn_ctx,
synth_funs,
grammar_map,
specification,
verifier,
phog_file,
options=options):
if len(synth_funs) > 1:
raise UnsuitableSolverException(
"DT Unification Solver: Multi-function unification not supported")
if specification.is_multipoint:
raise UnsuitableSolverException("Multi point specification")
synth_fun = synth_funs[0]
grammar = grammar_map[synth_fun]
decomposed_grammar = grammar.decompose(syn_ctx.macro_instantiator)
if decomposed_grammar == None:
raise UnsuitableSolverException(
"DT Unification Solver: Unable to decompose grammar")
term_grammar, pred_grammar, reverse_mapping = decomposed_grammar
generator_factory = enumerators.PointDistinctGeneratorFactory(
specification)
term_generator = term_grammar.to_generator(generator_factory)
pred_generator = pred_grammar.to_generator(generator_factory)
solver = solvers.Solver(syn_ctx)
term_phog = SPhog(term_grammar, phog_file, synth_fun.range_type, specification, for_eusolver=True, for_pred_exprs=False) if options.use_sphog() else \
Phog(term_grammar, phog_file, synth_fun.range_type, for_eusolver=True, for_pred_exprs=False)
pred_phog = SPhog(pred_grammar, phog_file, synth_fun.range_type, specification, for_eusolver=True, for_pred_exprs=True, ref_grammar=term_grammar) if options.use_sphog() else \
Phog(pred_grammar, phog_file, synth_fun.range_type, for_eusolver=True, for_pred_exprs=True)
if term_phog.stat_map is None:
print(
'No model available for this problem. We use the classic EUSolver ...'
)
term_phog = None
pred_phog = None
if pred_phog is not None and pred_phog.stat_map is None:
pred_phog = None
term_solver = termsolvers.PointDistinctTermSolver(
specification.term_signature, term_generator, stat_model=term_phog)
unifier = unifiers.PointDistinctDTUnifier(pred_generator,
term_solver,
synth_fun,
syn_ctx,
stat_model=pred_phog)
solver = solvers.Solver(syn_ctx)
solutions = solver.solve(generator_factory,
term_solver,
unifier,
verifier,
verify_term_solve=True)
solution = next(solutions)
final_solution = rewrite_solution([synth_fun], solution, reverse_mapping)
return final_solution
def memoryless_esolver(theory, syn_ctx, synth_funs, grammar_map, specification, verifier):
generator_factory = enumerators.RecursiveGeneratorFactory()
TermSolver = termsolvers.PointlessTermSolver
if len(synth_funs) > 1:
sf_list = [ (synth_fun.function_name, synth_fun, grammar_map[synth_fun])
for synth_fun in synth_funs ]
grammar = _merge_grammars(sf_list)
else:
grammar = grammar_map[synth_funs[0]]
term_generator = grammar.to_generator(generator_factory)
term_solver = TermSolver(specification.term_signature, term_generator)
term_solver.stopping_condition = termsolvers.StoppingCondition.one_term_sufficiency
unifier = unifiers.NullUnifier(None, term_solver, synth_funs, syn_ctx, specification)
solver = solvers.Solver(syn_ctx)
solutions = solver.solve(
generator_factory,
term_solver,
unifier,
verifier,
verify_term_solve=False
)
solution = next(solutions)
rewritten_solutions = rewrite_solution(synth_funs, solution, reverse_mapping=None)
return rewritten_solutions
def classic_esolver(theory, syn_ctx, synth_funs, grammar_map, specification, verifier):
if len(synth_funs) != 1:
raise UnsuitableSolverException("Classic esolver for multi-function disable due to bugs")
assert len(synth_funs) == 1
try:
generator_factory = enumerators.PointDistinctGeneratorFactory(specification)
except:
raise UnsuitableSolverException("Enumerator problems")
TermSolver = termsolvers.PointDistinctTermSolver
grammar = grammar_map[synth_funs[0]]
term_generator = grammar.to_generator(generator_factory)
term_solver = TermSolver(specification.term_signature, term_generator)
term_solver.stopping_condition = termsolvers.StoppingCondition.one_term_sufficiency
unifier = unifiers.NullUnifier(None, term_solver, synth_funs, syn_ctx, specification)
solver = solvers.Solver(syn_ctx)
solutions = solver.solve(
generator_factory,
term_solver,
unifier,
verifier,
verify_term_solve=False
)
try:
solution = next(solutions)
except StopIteration:
return "NO SOLUTION"
rewritten_solutions = rewrite_solution(synth_funs, solution, reverse_mapping=None)
return rewritten_solutions
def lia_unification_solver(theory, syn_ctx, synth_funs, grammar_map, specification, verifier):
if theory != 'LIA':
raise UnsuitableSolverException('LIA Unification Solver: Not LIA theory')
if any([sf.range_type != exprtypes.IntType() for sf in synth_funs ]):
raise UnsuitableSolverException('LIA Unification Solver: Cannot handle bool return values yet')
if not specification.is_pointwise():
raise UnsuitableSolverException('LIA Unification Solver: Not pointwise spec')
okay, massaging = full_lia_grammars(grammar_map)
if not okay:
raise UnsuitableSolverException('LIA Unification Solver: Could not get LIA full grammar')
term_solver = termsolvers_lia.SpecAwareLIATermSolver(specification.term_signature, specification)
unifier = unifiers_lia.SpecAwareLIAUnifier(None, term_solver, synth_funs, syn_ctx, specification)
solver = solvers.Solver(syn_ctx)
solutions = solver.solve(
enumerators.NullGeneratorFactory(),
term_solver,
unifier,
verifier,
verify_term_solve=False
)
solution = next(solutions)
final_solution = rewrite_solution(synth_funs, solution, reverse_mapping=None)
final_solution = lia_massager.massage_full_lia_solution(syn_ctx, synth_funs, final_solution, massaging)
if final_solution is None:
raise UnsuitableSolverException('LIA Unification Solver: Could not massage back solution')
return final_solution
def classic_esolver(theory, syn_ctx, synth_funs, grammar_map, specification,
verifier, phog_file):
if len(synth_funs) != 1:
raise UnsuitableSolverException(
"Classic esolver for multi-function disable due to bugs")
assert len(synth_funs) == 1
try:
generator_factory = enumerators.PointDistinctGeneratorFactory(
specification)
except:
raise UnsuitableSolverException("Enumerator problems")
TermSolver = termsolvers.PointDistinctTermSolver
grammar = grammar_map[synth_funs[0]]
term_generator = grammar.to_generator(generator_factory)
# init for using PHOG
phog = SPhog(grammar, phog_file, synth_funs[0].range_type, specification) if options.use_sphog() else \
Phog(grammar, phog_file, synth_funs[0].range_type)
if phog.stat_map is None:
print(
'No model available for this problem. We use the classic ESolver ...'
)
phog = None
term_solver = TermSolver(specification.term_signature,
term_generator,
stat_model=phog)
term_solver.stopping_condition = termsolvers.StoppingCondition.one_term_sufficiency
unifier = unifiers.NullUnifier(None, term_solver, synth_funs, syn_ctx,
specification)
solver = solvers.Solver(syn_ctx)
solutions = solver.solve(generator_factory,
term_solver,
unifier,
verifier,
verify_term_solve=False)
try:
solution = next(solutions)
except StopIteration:
return "NO SOLUTION"
rewritten_solutions = rewrite_solution(synth_funs,
solution,
reverse_mapping=None)
return rewritten_solutions