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]