def check_solver(s: Solver, num_states: int, minimize: Optional[bool] = None) -> Optional[Trace]:
res = s.check()
m = None
if res != solver.unsat:
if res != solver.sat:
assert res == solver.unknown
utils.logger.always_print('unknown!')
utils.logger.always_print('reason unknown: ' + s.reason_unknown())
assert False, 'unexpected unknown from z3!'
assert res == solver.sat
m = Z3Translator.model_to_trace(s.model(minimize=minimize), num_states)
return m
self[min_frame_no + 1].summary(),
[syntax.Not(expr)],
minimize=False)
if res is not None:
return bstate_min
bstate_min.known_absent_until_frame += 1
utils.logger.info('no existing states to block. looking for a new state.')
f = self.fs[-1]
if len(self.safeties) == 0 or (res := logic.check_implication(self.solver, f.summary(), self.safeties)) is None:
utils.logger.info('frontier is safe. nothing new to block either.')
return None
state = Z3Translator.model_to_trace(res, 1).as_state(0)
assert len(self) >= 2
bstate = BackwardReachableState(len(self.backwards_reachable_states), state, 0)
bstate.known_absent_until_frame = len(self) - 2
self.record_backwards_reachable_state(bstate)
return bstate
def record_backwards_reachable_state(self, state: BackwardReachableState) -> None:
utils.logger.info(f'discovered state #{len(self.backwards_reachable_states)}')
utils.logger.info(str(state))
self.backwards_reachable_states.append(state)
def get_inductive_frame(self) -> Optional[Frame]:
for i in range(len(self) - 1):
if self.is_frame_inductive(i):
return self[i + 1]