def to_tensor(s): assert len(s) == 4 assert s[-2:] == (None, None) return Tensor( [[[[z3.RealVal(1) / z3.RealVal(kx * ky) for i4 in range(ky)] for i3 in range(kx)] for i2 in range(s[1])] for i1 in range(s[0])])
def translate(self, term): """Translate a Maude term into an SMT formula""" symbol = term.symbol() # Variable if str(symbol) == str(term.getSort()): return smt.Const(str(term), self._smt_sort(term.getSort())) # Integer constant elif symbol == self.intlit_symb: return smt.IntVal(int(term)) # Real constant elif symbol == self.reallit_symb: return smt.RealVal(float(term)) # Other symbols else: symb = self.ops_table.get(symbol) # If the symbol is not in the table, it may be a # polymorph for a custom type... if symb is None: symb = self._make_polymorph(symbol) # ...or an uninterpreted function if symb is None: symb = self._make_function(symbol) return symb(*[self.translate(arg) for arg in term.arguments()])
def pyval2z3val(val): if type(val) is float: return z3.RealVal(val) elif type(val) is int: return z3.IntVal(val) else: raise err.Fatal('unhandled python val type!')
def _py2expr(a, ctx=None): if isinstance(a, bool): return z3.BoolVal(a, ctx) if isinstance(a, int): return z3.IntVal(a, ctx) if isinstance(a, float): return z3.RealVal(a, ctx)
def get_z3_val(valtype, value, name, datatype_name=None, ctx=None): val = None if isinstance(valtype, z3.z3.DatatypeSortRef): # discrete values datatype val = getattr(valtype, value) elif valtype is Types.INT: try: val = z3.BitVecVal(value, 32, ctx=ctx) except Exception as exc: raise ValueError( f"Error during INT conversion. Cannot convert value: {value}, type: {type(value)}, name: {name}" ) elif valtype is Types.INTEGER: try: val = z3.IntVal(value, ctx=ctx) except Exception as exc: raise ValueError( f"Error during INTEGER conversion. Cannot convert value: {value}, type: {type(value)}, name: {name}" ) elif valtype is Types.FLOAT: try: val = z3.FPVal(value, z3.Float32(), ctx=ctx) except Exception as exc: raise ValueError( f"Error during FLOAT conversion. Cannot convert value: {value}, type: {type(value)}, name: {name}" ) elif valtype is Types.REAL: try: val = z3.RealVal(value, ctx=ctx) except Exception as exc: raise ValueError( f"Error during REAL conversion. Cannot convert value: {value}, type: {type(value)}, name: {name}" ) elif valtype is Types.BOOL: try: val = z3.BoolVal(value, ctx=ctx) except Exception as exc: raise ValueError( f"Error during BOOL conversion of value to INT. value: {value}, type: {type(value)}, name: {name}" ) elif valtype is Types.STRING: try: val = z3.StringVal(value, ctx=ctx) except Exception as exc: raise ValueError( f"Error during STRING conversion of value to INT. value: {value}, type: {type(value)}, name: {name}" ) elif isinstance(valtype, list): datatype = _get_datatype_from_list(valtype, datatype_name) val = getattr(datatype, value) valtype = datatype else: raise ValueError( f"I do not know how to create a z3-value for type {valtype}") assert val is not None, f"Value wasn't converted: valtype: {valtype}, value: {value}, name: {name}" val.type = valtype return val
def _link_constant(self, phi): assert isinstance(phi, amnet.Constant) # *overwrite* the output variable of phi to be a z3 RealVal assert self.ctx.is_valid() name = self.ctx.name_of(phi) assert len(phi.b) == len(self.vars[name]) # pre-overwrite self.vars[name] = [z3.RealVal(bi) for bi in phi.b] assert self.ctx.is_valid() # post-overwrite
def __parse_constant__(self, symbol_node: jcmuta.SymbolNode): constant = symbol_node.get_content().get_token_value() if isinstance(constant, bool): return z3.BoolVal(constant) elif isinstance(constant, int): if self.bitSwitch: return z3.BitVecVal(constant, self.longSize) else: return z3.IntVal(constant) else: return z3.RealVal(constant)
def trans(self, term): sort = type_to_data_sort(term.type) if isinstance(sort, z3.ArithSortRef): if sort.is_real(): return z3.RealVal(term.literal) else: return z3.IntVal(term.literal) elif isinstance(sort, z3.BoolSortRef): return z3.BoolVal(term.literal) else: # TODO: Unsupported literal terms, just create fresh variable return self.mkVar(term.type)
def to_z3_obj(arg, typ, ident_t=None, bitlen=32): def intern_int(x): if len(x) == 3: return z3.BitVecVal(int(x[2], 16), bitlen) elif len(x) == 2: return z3.BitVecVal(int(x[1], 8), bitlen) else: return z3.BitVecVal(int(x[0]), bitlen) id_t_2_z3 = { ptx.integer_literal: lambda x: z3.BitVec(x, bitlen), ptx.float_literal: z3.Real, ptx.double_literal: z3.Real, ptx.predicate_const: z3.Bool } return { ptx.integer_literal: intern_int, ptx.float_literal: lambda x: z3.RealVal(struct.unpack('f', x)[0]), ptx.double_literal: lambda x: z3.RealVal(struct.unpack('d', x)[0]), ptx.predicate_const: lambda x: z3.BoolVal(bool(x)), ptx.identifier: lambda x: id_t_2_z3[ident_t](''.join(x)) }[typ](arg)
def check_e12(): r120 = z3.IntVal(120) r444 = z3.IntVal(444) r1_2 = z3.RealVal(1.2) r2_1 = z3.RealVal(2.1) # segfaults e12 = z3.SetSort(z3.IntSort()) z3.SetAdd(e12, 12) constraints = [ #z3.IsMember(r1_2, e12), #z3.IsMember(r2_1, e12), ] s = z3.Solver() for c in constraints: s.add(c) print('checking', s, s.check()) satisfied = str(s.check()) == 'sat' assert satisfied, s
def getZ3Object(self, increment=False): """ Returns the z3 object for this variable """ if increment: self.increment() if self.value is None: return z3.Real("{0}{1}@{2}".format(self.count, self.varName, self.ctx), ctx=self.state.solver.ctx) return z3.RealVal(self.value)
def __new_constant__(self, constant, code: int): """ :param constant: bool | int | float :param code: :return: """ if isinstance(constant, bool): return z3.BoolVal(constant) elif isinstance(constant, int): if code == self.__s_code__: return z3.BitVecVal(constant, self.longLength) else: return z3.IntVal(constant) else: return z3.RealVal(constant)
def model2var_realVec(model, outputVarList, var2dim_dict): sample_dict = {} for output_arr in outputVarList: num_elements = var2dim_dict[str(output_arr)] x_arr = [model[output_arr[i]] for i in range(num_elements)] # TODO: replace all vars which have no models with 0 # Is this handling correct? x_arr = [z3.RealVal(0) if x is None else x for x in x_arr] x_arr = [z3val2pyval(x) for x in x_arr] #print(str(output_arr)) #print(x_arr) sample_dict[str(output_arr)] = x_arr #print(sample_dict) #exit() return sample_dict
def pool2d_avg_0(kx, ky, sx, sy, pad, A): assert pad in [PD_MODE_SAME, PD_MODE_VALID] sa = A.shape require(len(sa) == 4) require(sx > 0 and sy > 0) if pad == PD_MODE_SAME: # same padding ox = (sa[2] + sx - 1) / sx oy = (sa[3] + sy - 1) / sy if sa[2] % sx == 0: totalPadH = max(kx - sx, 0) else: totalPadH = max(kx - (sa[2] % sx), 0) if sa[3] % sy == 0: totalPadW = max(ky - sy, 0) else: totalPadW = max(ky - (sa[3] % sy), 0) px = (totalPadH + 1) / 2 py = (totalPadW + 1) / 2 elif pad == PD_MODE_VALID: # valid padding ox = (sa[2] - kx) / sx + 1 oy = (sa[3] - ky) / sy + 1 px = 0 py = 0 else: assert False so = (sa[0], sa[1], ox, oy) require(ox > 0 and oy > 0) C = Tensor.zeros(so) for n in range(so[0]): for c in range(so[1]): for h in range(so[2]): for w in range(so[3]): value = 0 for kh in range(kx): for kw in range(ky): posH = h * sx + kh - px posW = w * sy + kw - py assert -px <= posH <= sa[2] + px, posH assert -py <= posW <= sa[3] + py, (posW, h, w, sx, sy, kh, kw, py, so) if posH >= 0 and posH < sa[ 2] and posW >= 0 and posW < sa[3]: value += A[n, c, posH, posW] C[n, c, h, w] = value / z3.RealVal(kx * ky) C.splits = (A.splits[0], A.splits[1], (), ()) return C
# ne.name: (lambda args, context: args[0] != args[1]), # Sum.name: (lambda args, context: z3.Sum(args)), # Product.name: (lambda args, context: z3.Product(args)), # gt.name: (lambda args, context: args[0] > args[1]), # ge.name: (lambda args, context: args[0] >= args[1]) } _built_in_z3_sorts = { Int.name: z3.IntSort, Real.name: z3.RealSort, Bool.name: z3.BoolSort } _built_in_z3_sort_values = { Int.name: (lambda s, ctxt: z3.IntVal(int(s), ctxt)), Real.name: (lambda s, ctxt: z3.RealVal(float(s), ctxt)), Bool.name: (lambda s, ctxt: z3.BoolVal(bool(s), ctxt)) } ############################################################################### # # Convert Boole expressions to Z3 expressions # ############################################################################### def z3_to_fun(z3_expr): """Takes a FuncInterp instance, and returns the function which takes as input a z3 expression and returns the value of the corresponding expression.
def getDecimalValue(v0): v = z3.RealVal(str(v0)) return long(v.numerator_as_long()) / v.denominator_as_long()
def _from_mc_result_to_z3_ref(self, val): #TODO super nasty. return z3.RealVal(str(val))
import z3 if __name__ == '__main__': x = z3.Real('x') const = z3.RealVal(1) / 3 z3.set_option(rational_to_decimal=True) z3.solve(x + const == 0)
def z3_matchLeftAndRight(left,right,op): """Appropriately change the two variables so that they can be used in an expression Parameters ---------- left,right : pyObjectManager.Int.Int or pyObjectManager.Real.Real or pyObjectManager.BitVec.BitVec or pyObjectManager.Char.Char Objects to be matched op : ast.* Operation that will be performed Returns ------- tuple (z3ObjectLeft,z3ObjectRight) tuple of z3 objects that can be used in an expression The purpose of this function is to match two pyObjectManager.* variables to a given ast operation element. Z3 needs to have matched types, and this call will not only match the objects, but also attempt to concretize input wherever possible. Example ------- If you want to auto-match BitVector sizes:: In [1]: import z3, pyState.z3Helpers, ast In [2]: from pySym.pyObjectManager.BitVec import BitVec In [3]: from pySym.pyState import State In [4]: state = State() In [5]: x = BitVec("x",0,16,state=state) In [6]: y = BitVec("y",0,32,state=state) In [7]: l,r = pyState.z3Helpers.z3_matchLeftAndRight(x,y,ast.Add()) In [8]: s = z3.Solver() In [9]: s.add(l + r == 12) In [10]: s Out[10]: [SignExt(16, 0x@0) + 0y@0 == 12] In [11]: s.check() Out[11]: sat """ lType = type(left) rType = type(right) # If it's char, just grab the BitVec object if lType is Char: left = left.variable lType = type(left) if rType is Char: right = right.variable rType = type(right) logger.debug("z3_matchLeftAndRight: Called to match {0} and {1}".format(type(left),type(right))) needBitVec = True if type(op) in [ast.BitXor, ast.BitAnd, ast.BitOr, ast.LShift, ast.RShift] else False # TODO: If the two sizes are different, we'll have problems down the road. bitVecSize = max([c.size for c in [b for b in [left,right] if type(b) is BitVec]],default=Z3_DEFAULT_BITVEC_SIZE) ##################################### # Case: Both are already BitVectors # ##################################### # Check length. Extend if needed. if type(left) is BitVec and type(right) is BitVec: logger.debug("z3_matchLeftAndRight: Matching BitVecLength @ {0} (left={1},right={2})".format(bitVecSize,left.size,right.size)) if left.size < right.size: # Sign extend left's value to match left = z3.SignExt(right.size-left.size,left.getZ3Object()) right = right.getZ3Object() elif right.size > left.size: right = z3.SignExt(left.size-right.size,right.getZ3Object()) left = left.getZ3Object() # Sync-up the output variables left = left.getZ3Object() if type(left) in [Int, Real, BitVec] else left right = right.getZ3Object() if type(right) in [Int, Real, BitVec] else right logger.debug("z3_matchLeftAndRight: Returning {0} and {1}".format(type(left),type(right))) return left,right ##################################### # Case: One is BitVec and one isn't # ##################################### # For now only handling casting of int to BV. Not other way around. if (lType is BitVec and rType is Int) or (rType is Int and needBitVec): # If we need to convert to BitVec and it is a constant, not variable, do so more directly if right.isStatic(): right = z3.BitVecVal(right.getValue(),bitVecSize) # Otherwise cast it. Not optimal, but oh well. else: right = z3_int_to_bv(right.getZ3Object(),size=bitVecSize) if (rType is BitVec and lType is Int) or (lType is Int and needBitVec): if left.isStatic(): left = z3.BitVecVal(left.getValue(),bitVecSize) else: left = z3_int_to_bv(left.getZ3Object(),size=bitVecSize) ################################ # Case: One is Int one is Real # ################################ # So long as this isn't modular arithmetic, let's change to Real things if lType is Real and rType is Int and type(op) is not ast.Mod: if right.isStatic(): right = z3.RealVal(right.getValue()) else: # TODO: Z3 is really bad at handling these... right = z3.ToReal(right.getZ3Object()) if rType is Real and lType is Int and type(op) is not ast.Mod: if left.isStatic(): left = z3.RealVal(left.getValue()) else: # TODO: Z3 is really bad at handling these... left = z3.ToReal(left.getZ3Object()) ############################################ # Case: One is Int one is Real for ast.Mod # ############################################ # So long as this isn't modular arithmetic, let's change to Real things if lType is Real and rType is Int and type(op) is ast.Mod: if left.isStatic(): leftVal = left.getValue() left = z3.IntVal(leftVal) if int(leftVal) != leftVal: logger.warn("Truncating value for Modular Arithmetic. That may or may not be what was intended!") # See if we can swing this the other direction elif right.isStatic(): rightVal = right.getValue() right = z3.RealVal(rightVal) if rType is Real and lType is Int and type(op) is ast.Mod: if right.isStatic(): rightVal = right.getValue() right = z3.IntVal(rightVal) if int(rightVal) != rightVal: logger.warn("Truncating value for Modular Arithmetic. That may or may not be what was intended!") # See if we can swing this the other direction else: left = z3.RealVal(left.getValue()) # Sync-up the output variables left = left.getZ3Object() if type(left) in [Int, Real, BitVec] else left right = right.getZ3Object() if type(right) in [Int, Real, BitVec] else right logger.debug("z3_matchLeftAndRight: Returning {0} and {1}".format(type(left),type(right))) return left,right
def noise_sensor(ram_kb=32, storage_kb=128, transmit_period_hours=1, noise_window=1 / 8, noiseid_window=60, noiseid_samplerate=4, noiseid_max_percent=0.01, mic_a=500e-6, sleep_a=250e-6, cpu_run_a=2e-3, modem_a=50e-3, battery_selfdischarge=0.05, battery_days=365, battery_mah=1400): import z3 # take into account self-discharge battery_mah = battery_mah * (1.0 - battery_selfdischarge) battery_uas = battery_mah * 1000 * 3600 energy_day = battery_uas / battery_days transmit_period = transmit_period_hours / 24 * 60 * 60 assert noiseid_samplerate < 10 # keep unintelligeble assert noiseid_samplerate > 1 # keep useful noiseid_data = octave_bands_ram(noiseid_window, noiseid_samplerate) noiseid_max_samples = noiseid_max_percent * (transmit_period_hours * 60 * 60 / noiseid_window) noiseid_storage = noiseid_data * noiseid_max_samples noise_storage = transmit_period_hours * 60 * 60 / noise_window data_sizes = [ noise_storage, noiseid_storage, ] storage_needed = sum(data_sizes) storage_size = storage_kb * 1000 transmit_time = radio_time(sum(data_sizes)) # noise sent as one packet, noiseid as N packets transmit_ram = max(noise_storage, noiseid_data) print('t time', transmit_time) ram_use = [ z3.IntVal(256 * 8), # audio buffers z3.IntVal(noiseid_data), z3.IntVal(transmit_ram), ] cpu_ram = z3.Int('cpu_ram') cpu_use = [ (16e-6, 16e-3), # audio read (160e-6, 16e-3), # noise calc (transmit_time, transmit_period), # transmit ] cpu_use_sum = sum(t / p for t, p in cpu_use) assert cpu_use_sum < 1.0, cpu_use assert cpu_use_sum > 0.0, cpu_use def energy(amp, seconds=1.0, period=1.0): ua = amp * 1e6 dutycycle = seconds / period tot = ua * dutycycle print('e', tot, dutycycle) return tot energy_use = [ z3.RealVal(energy(mic_a)), # base, microphone z3.RealVal(energy(sleep_a)), # base, sleeping z3.RealVal(energy(modem_a, transmit_time, transmit_period)), # transmit ] energy_use += [z3.RealVal(energy(cpu_run_a, *c)) for c in cpu_use] energy_budget = z3.Int('energy_budget') energy_spend = z3.Real('energy_use') ram_left = z3.Int('ram_left') energy_left = z3.Real('energy_left') storage_left = z3.Int('storage_left') print('b', (energy_day / (1000 * 24)) * battery_days) constraints = [ cpu_ram == ram_kb * 1000, energy_budget == energy_day, ram_left == cpu_ram - z3.Sum(ram_use), energy_spend == z3.Sum(energy_use), energy_left == energy_budget - energy_spend, storage_left == z3.IntVal(storage_size) - z3.IntVal(storage_needed), ram_left > 0, energy_left > 0, storage_left > 0, ] s = z3.Solver() for c in constraints: s.add(c) return s
def _parseSmt1String(self, string): #self._logger.setVerbose(True) stack = list() functionSymbols = '&|~<=*+-' try: string = string.replace('\n', '').split('(') idx = 0 for pos, elem in enumerate(string): self._logger.writeToLog('{} - reading :{}:'.format(pos, elem)) if elem == '': continue elemL = elem.split() # ALL lines should start with '(' if elemL[0] in functionSymbols: stack.append(elemL[0]) elif elemL[0] == 'var': varName = elemL[2].replace(')', '') if elemL[1] == 'bool': formula = z3.Bool(varName) stack.append(self._abstraction(formula)) elif elemL[1] == 'real': formula = z3.Real(varName) stack.append(formula) elif elemL[1] == 'int': formula = z3.Int(varName) stack.append(formula) else: raise Exception( 'Unknown Variable format: {}'.format(elemL)) elif elemL[0] == 'const': const = elemL[2].replace(')', '') if elemL[1] == 'real': stack.append(z3.RealVal(const)) elif elemL[1] == 'int': stack.append(z3.IntVal(const)) else: raise Exception( 'Unknown Constant format: {}'.format(elemL)) else: raise Exception('Unknown format : {}'.format(elemL)) closedBrackets = elem.count(')') - 1 self._logger.writeToLog( "{} - new element in stack: {}\t,cB {}".format( pos, stack[-1], closedBrackets)) if closedBrackets < 1: continue while closedBrackets > 0: self._logger.writeToLog('{} - stack: {},{}'.format( pos, stack, closedBrackets)) tmpPredi = [] pred = None while True: pred = stack.pop() #if isinstance(pred,Predicate) or isinstance(pred,z3.BoolRef) or str(pred).replace('.','',1).isdigit(): #if z3.is_rational_value(pred) or z3.is_int_value(pred) or z3.is_int(pred) or z3.is_real(pred) or z3.is_bool(pred): if isinstance(pred, float) or isinstance( pred, int) or z3.is_int(pred) or z3.is_real( pred) or z3.is_bool(pred): tmpPredi.append(pred) else: if len(tmpPredi) == 1: tmpPredi = tmpPredi[0] else: tmpPredi = tmpPredi[::-1] break self._logger.writeToLog('{} - {} is applied to {}'.format( pos, pred, tmpPredi)) newElem = self._mapFunctionSymbol(pred)(tmpPredi) # newElemSimplified = z3.simplify(newElem) stack.append(newElem) self._logger.writeToLog( "{} - new element in stack: {}\t,cB {}".format( pos, stack[-1], closedBrackets)) closedBrackets -= 1 self._logger.writeToLog('{} - finished :{}:'.format( pos, stack)) except Exception as e: self._logger.writeToLog( "Some Error : {}\n\t Occured parsing formula: {}".format( e, string)) raise e if len(stack) != 1: raise Exception("Parsing Error, stack != 1") return self._recusiveSimplification(stack[0])
def cfp_to_z3(e,solver=None): return z3.RealVal(e.v)
def cfp_to_z3(e, slv=None): return z3.RealVal(e.v)
def cfp_to_z3(e, slv=None): "translate cfp expression into its z3 RealVal form" return z3.RealVal(e.v)
def opamp_components(): # Components of our system components = dict( r_in=z3.Int('r_in'), r_f=z3.Int('r_f'), c_in=z3.Int('c_in'), c_out=z3.Int('c_out'), c_f=z3.Int('c_f'), ) # XXX: capacitors in picofarad, to keep them integer valued # The foreign systems we are connecting to # for example a piezo element on input, # and a line-level amplifier on output input_z = 1e6 output_z = 10e3 # Actual selected f_upper = z3.Real('f_upper') f_lower = z3.Real('f_lower') gain = z3.Real('gain') # Functional requirements for our amplifier gain_desired = z3.RealVal(22.0) gain_tolerance = z3.RealVal(0.05) # relative functional_requirements = [ (gain * (1 + gain_tolerance) >= gain_desired), (gain * (1 - gain_tolerance) <= gain_desired), #f_upper > z3.RealVal(10e3), #f_upper < z3.RealVal(20e3), f_lower < z3.RealVal(10.0), f_lower > z3.RealVal(1.0), ] # How the amplifier circuit works # XXX: assumes that the filters are independent (no interactions) # reasonable in many practical cases, but not guaranteed f_in = z3.Real('f_in') f_out = z3.Real('f_out') c = components circuit_constraints = [ c['r_f'] == 3300, #c['c_f'] > 1, c['c_f'] != 0, gain == opamp_gain_ni(c['r_in'], c['r_f']), #f_in == filter_cutoff(input_z, c['c_in']*z3.RealVal(1e-6)), #f_out == filter_cutoff(output_z, c['c_out']*z3.RealVal(1e-6)), f_lower < f_in, f_lower < f_out, f_upper == filter_cutoff(c['r_f'], c['c_f'], z3.RealVal(1e-6)), ] # TODO: constraint # all components must be in E12 component_values = e_values() component_constraints = [] #component_constraints = [ v > 0 for v in components.values() ] #component_constraints += [ v < 1000000000 for v in components.values() ] #component_constraints = [ component_value_constraint(v, component_values) for v in components.values() ] # TODO: match components against others on the board # EX: decoupling capacitors constraints = functional_requirements + \ circuit_constraints + \ component_constraints zmodels = get_models(constraints, M=100) models = [] for model in zmodels: results = {} for var in model: results[str(var)] = model[var] models.append(results) resistors = set([v for v in models[0].keys() if v.startswith('r_')]) capacitors = set([v for v in models[0].keys() if v.startswith('c_')]) print(resistors, capacitors) def unique_component_values(res): r_values = set(v for k, v in res.items() if k in resistors) c_values = set(v for k, v in res.items() if k in capacitors) #print(r_values, c_values) print() return len(r_values) + len(c_values) preferred = sorted(models, key=lambda r: unique_component_values(r)) print(preferred[0])
import re from typing import Tuple, Dict, Union, Set, List FP_OPS = ["fmul", "fdiv", "fadd", "fsub"] IGNORED_OPS = ["ret", "br"] VAR_REGEX = re.compile(r"%[a-zA-Z0-9]+") NUM_REGEX = re.compile(r"[0-9]+.[0-9]+e(\+|\-)[0-9]+") HEX_REGEX = re.compile(r"0x[0-9a-fA-F]+") ARG_REGEX = re.compile( r"(%s)|(%s)|(%s)" % (VAR_REGEX.pattern, NUM_REGEX.pattern, HEX_REGEX.pattern)) DBL_MAX = z3.RealVal( "179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0" ) # noqa DBL_MIN = z3.RealVal( "0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000222507385850720138309023271733240406421921598046233183055332741688720443481391819585428315901251102056406733973103581100515243416155346010885601238537771882113077799353200233047961014744258363607192156504694250373420837525080665061665815894872049117996859163964850063590877011830487479978088775374994945158045160505091539985658247081864511353793580499211598108576" ) # noqa FloatArith = Union[float, z3.ArithRef] class Constraint: def __init__(self, name: str, instr: str, formula: z3.ArithRef): self.name = name self.instruction = instr self.formula = formula def _and(self, other: z3.ArithRef):
def walk_real_constant(self, formula, **kwargs): frac = formula.constant_value() n,d = frac.numerator, frac.denominator rep = str(n) + "/" + str(d) return z3.RealVal(rep)