from abc import ABCMeta, abstractmethod
from sage.all import (PolynomialRing, QQ, sage_eval, operator, SR)
from vu_common import (VLog, vsetdiff,
is_str, is_list, is_dict, is_tuple,
merge_dict)
from sageutil import get_vars, is_sage_expr
from dig_miscs import Miscs, ExtFun
logger = VLog('dig_inv')
logger.set_level(VLog.INFO)
class Inv(object):
__metaclass__ = ABCMeta
def __init__(self, p, p_str=None):
if __debug__:
assert p_str is None or is_str(p_str), p_str
self.p = p
if p_str is None:
p_str = str(p)
self.p_str = Inv.rm_lambda(p_str)
def __eq__(self,other): return self.p.__eq__(other.p)
def __ne__(self,other): return self.p.__ne__(other.p)
def __hash__(self): return self.p.__hash__()
def __str__(self): return self.p_str
def __repr__(self): return self.p.__repr__()
from abc import ABCMeta, abstractmethod
from sage.all import (PolynomialRing, QQ, sage_eval, operator, SR)
from vu_common import (VLog, vsetdiff, is_str, is_list, is_dict, is_tuple,
merge_dict)
from sageutil import get_vars, is_sage_expr
from dig_miscs import Miscs, ExtFun
logger = VLog('dig_inv')
logger.set_level(VLog.INFO)
class Inv(object):
__metaclass__ = ABCMeta
def __init__(self, p, p_str=None):
if __debug__:
assert p_str is None or is_str(p_str), p_str
self.p = p
if p_str is None:
p_str = str(p)
self.p_str = Inv.rm_lambda(p_str)
def __eq__(self, other):
return self.p.__eq__(other.p)
def __ne__(self, other):
return self.p.__ne__(other.p)
from collections import OrderedDict
from pprint import pprint
import multiprocessing as mp
from sage.all import (SR, srange, var, flatten)
from sageutil import (get_vars, get_coefs_terms, is_sage_eq)
from vu_common import (VLog, vall_uniq, is_empty, is_list, is_dict,
merge_dict, vpartition, list_str)
from dig_miscs import (Miscs, get_traces, Tree, AEXP, ExtFun, adjust_arr_sizs)
from dig import Solver
from dig_inv import InvEqt, InvFlatArray, InvNestedArray
logger = VLog('dig_arrays')
logger.level = VLog.DEBUG
class FlatArray(Solver):
"""
Find Flat Array Invariants of the form
c1A[i][j].. + c2B[i1'][i2'].. = 0
using standard equation solving
Examples:
ig = InvGen("Traces/AES/Flat/paper_multidim.tc",verbose=1)
_ = ig.getInvs(inv_typ='flat',seed=1)
*** InvGen ***
Sun Jun 3 21:44:39 2012
Sage Version 5.0, Release Date: 2012-05-14
from sage.all import operator
from vu_common import (VLog, pause, is_list, is_empty, vset)
from dig_inv import Inv, InvExp, InvEqt, InvMPP, InvIeq
logger = VLog('refine')
logger.level = VLog.INFO
class Refine(object):
"""
Refine result invariants using several techniques, including
1) filtering
2) inferring
3) ranking
"""
def __init__(self, ps):
if __debug__:
assert is_list(ps) and all(isinstance(p,Inv) for p in ps), ps
self.ps = vset(ps)
Refine.print_diff('vset', len(ps), len(self.ps))
def get_ps(self):
return self._ps
def set_ps(self, ps):
if __debug__:
assert all(isinstance(p,Inv) for p in ps), p
self._ps = ps
from abc import ABCMeta, abstractmethod
import multiprocessing as mp
from sage.all import (set_random_seed, version)
from vu_common import (VLog, pause, is_str, is_dict, is_list, is_empty,
get_cur_time)
import dig_miscs
from dig_inv import Inv
logger = VLog('dig')
"""
Design notes:
Information should be output from this file and not too much from other files.
"""
class DIG(object):
"""
Main class to generate invariants by making calls to other classes
to get different types of invariants
Examples:
See usage examples in classes Eqt, Ineqs, FlatArray, NestedArray
"""
def __init__(self, filename, verbose=VLog.DEBUG):
if __debug__:
assert filename is None or is_str(filename), filename
logger.level = verbose
import itertools
import multiprocessing as mp
from abc import ABCMeta, abstractmethod
from sage.all import (flatten, solve, srange, operator, sage_eval, prod,
Polyhedron, CartesianProduct, Combinations, SR, RR, QQ,
PolynomialRing, operator, oo, is_even)
from sageutil import (get_vars, is_sage_symbol, is_sage_int, is_sage_expr,
is_sage_rel)
from vu_common import (VLog, pause, vset, is_empty, is_list, is_bool, vcmd)
from dig_miscs import (Miscs, get_traces, get_sample, gen_terms_fixed_coefs)
from dig import Solver
from dig_inv import InvEqt, InvIeq, InvMPP
logger = VLog('dig_polynomials')
logger.level = VLog.INFO
class Eqt(Solver):
"""
Find equality invariants using standard equation solving
"""
def __init__(self, terms, tcs, xinfo):
super(Eqt, self).__init__(terms, tcs, xinfo)
def mk_traces(self):
"""
No need to do too much filtering because
most eqts obtained are valid
"""
import multiprocessing as mp
from abc import ABCMeta, abstractmethod
from sage.all import (flatten, solve, srange, operator, sage_eval, prod,
Polyhedron, CartesianProduct, Combinations,
SR, RR, QQ, PolynomialRing, operator, oo, is_even)
from sageutil import (get_vars, is_sage_symbol, is_sage_int,
is_sage_expr, is_sage_rel)
from vu_common import (VLog, pause, vset, is_empty, is_list, is_bool, vcmd)
from dig_miscs import (Miscs, get_traces, get_sample,
gen_terms_fixed_coefs)
from dig import Solver
from dig_inv import InvEqt, InvIeq, InvMPP
logger = VLog('dig_polynomials')
logger.level = VLog.INFO
class Eqt(Solver):
"""
Find equality invariants using standard equation solving
"""
def __init__(self,terms,tcs,xinfo):
super(Eqt,self).__init__(terms, tcs, xinfo)
def mk_traces(self):
"""
No need to do too much filtering because
most eqts obtained are valid
