def generate_transitive_assumptions(self):
trans_assumpts = list()
for symbol in self.symbol_assumptions:
assumpt_dict = self.symbol_assumptions[symbol]
if '>' in assumpt_dict:
for assump1 in assumpt_dict['>']:
if '<' in assumpt_dict:
for assump2 in assumpt_dict['<']:
trans_assumpts.append(assumption(assump1, '<', assump2))
if '<=' in assumpt_dict:
for assump2 in assumpt_dict['<=']:
trans_assumpts.append(assumption(assump1, '<=', assump2))
if '>=' in assumpt_dict:
for assump1 in assumpt_dict['>=']:
if '<' in assumpt_dict:
for assump2 in assumpt_dict['<']:
trans_assumpts.append(assumption(assump1, '<=', assump2))
if '<=' in assumpt_dict:
for assump2 in assumpt_dict['<=']:
trans_assumpts.append(assumption(assump1, '<=', assump2))
if '==' in assumpt_dict:
for assump1 in assumpt_dict['==']:
for assump2 in assumpt_dict['==']:
if assump1 != assump2:
trans_assumpts.append(assumption(assump1, '==', assump2))
dedup(trans_assumpts)
return trans_assumpts
def assumption_not_equal_ratio_to_linear(assumpt, pot):
variations = variations_for_pot(pot)
num_mults = list()
assumpt.exp = assumpt.exp.simplify()
(num, denom) = assumpt.exp.as_numer_denom()
if denom.is_number and denom.is_zero:
return variations.get_linear_assumption_list()
if not num.is_number:
num_dict = num.combsimp().as_powers_dict()
for m in num_dict:
if not m.is_number:
num_mults.append(m)
elif m.is_zero:
return variations.get_linear_assumption_list()
else:
if num.is_zero:
return variations.get_linear_assumption_list()
else:
variations.add_assumption(assumption(Number(0), '==', Number(0)))
return variations.get_linear_assumption_list()
variations.new_variation()
for m in num_mults:
if not variations.add_assumption(assumption(m, '!=', Number(0))):
break
return variations.get_linear_assumption_list()
def get_next_tables_multi(self):
doubt_assumpts = list()
for (j, targ) in enumerate(self.target):
assumpt = assumption(targ, '<', Number(0))
res = self.test_assumtions([assumpt, ])
if res == result.not_possible: continue
doubt_assumpts.append((j, targ))
for j, targ in doubt_assumpts:
if j in self.basis: continue
assumpts = list()
for i, a in doubt_assumpts:
if i < j:
assumpts.append(assumption(targ, '<', a ) )
elif i == j:
assumpts.append(assumption(targ, '<', Number(0) ) )
else:
assumpts.append(assumption(targ, '<=', a ) )
yield( (j, assumpts) )
if len(doubt_assumpts) > 0:
assumpts = list()
for i, a in doubt_assumpts:
assumpts.append(assumption(a, '>=', Number(0) ) )
yield ( (-1, assumpts) )
def get_assumptions(self, symbol):
ret = list()
if self.right_value != float("inf"):
if self.right_strong:
ret.append(assumption(symbol, "<", Number(self.right_value)))
else:
ret.append(assumption(symbol, "<=", Number(self.right_value)))
if self.left_value != float("-inf"):
if self.left_strong:
ret.append(assumption(symbol, ">", Number(self.left_value)))
else:
ret.append(assumption(symbol, ">=", Number(self.left_value)))
return ret
def prepare_decomposed_assumptions(assumpt, assumpt_deps):
variants = decomposed_assumption()
for symbol in assumpt_deps:
res = try_assumpt_linear(assumpt, symbol)
if not res: continue
a, b = res
sign = assumpt.sign
variants.new_variant_group()
if sign == '==':
variants.new_variant()
variants.add_assumption( assumption(a, '!=', Number(0)) )
variants.add_symbol_assumption( (symbol, '==', Number(-1)*b/a ) )
variants.new_variant()
variants.add_assumption( assumption(a, '==', Number(0)) )
variants.add_assumption( assumption(b, '==', Number(0)) )
elif sign == '!=':
variants.new_variant()
variants.add_assumption( assumption(a, '!=', Number(0)) )
variants.add_symbol_assumption( (symbol, '!=', Number(-1)*b/a) )
variants.new_variant()
variants.add_assumption( assumption(a, '==', Number(0)) )
variants.add_assumption( assumption(b, '!=', Number(0)) )
else:
if sign == '>': neg_sign = '<'
elif sign == '>=': neg_sign = '<='
elif sign == '<': neg_sign = '>'
else: neg_sign = '>='
variants.new_variant()
variants.add_assumption( assumption(a, '>', Number(0)) )
variants.add_symbol_assumption( (symbol, sign, Number(-1)*b/a) )
variants.new_variant()
variants.add_assumption( assumption(a, '<', Number(0)) )
variants.add_symbol_assumption( (symbol, neg_sign, Number(-1)*b/a) )
variants.new_variant()
variants.add_assumption( assumption(a, '==', Number(0)) )
variants.add_assumption( assumption(b, sign, Number(0)) )
variants.new_variant_group()
return variants
def get_next_tables(self):
doubt_assumpts = list()
for (j, targ) in enumerate(self.target):
assumpt = assumption(targ, '<', Number(0))
res = self.test_assumtions([assumpt, ])
if res == result.not_possible: continue
doubt_assumpts.append((j, targ))
for j, targ in doubt_assumpts:
if j in self.basis: continue
assumpts = list()
for i, a in doubt_assumpts:
if i < j:
assumpts.append(assumption(targ, '<', a ) )
elif i == j:
assumpts.append(assumption(targ, '<', Number(0) ) )
else:
assumpts.append(assumption(targ, '<=', a ) )
res = self.test_assumtions(assumpts)
if res == result.not_possible: continue
for table in self.get_next_tables_by_row(j, assumpts):
yield table
if len(doubt_assumpts) > 0:
assumpts = list()
for i, a in doubt_assumpts:
assumpts.append(assumption(a, '>=', Number(0) ) )
next = simplex_table()
next.amount_of_vars = self.amount_of_vars
next.amount_of_equations = self.amount_of_equations
next.basis = self.basis[:]
next.free = self.free[:]
next.limits = deepcopy(self.limits)
next.target = self.target[:]
next.target_free = self.target_free
res, pot = self.test_and_add_assumptions(assumpts)
if res != result.not_possible:
next.pots = pot
next.path = self.path + [(-1,-1,-1)]
yield next
def get_next_tables_multi_by_column_and_row(self, assumpts, j, i):
#if i in self.basis: return None
assumps2 = list()
assumps2.append(assumption(self.limits[i][j], '>', Number(0)))
or_assumps = self.prepare_or_assumptions(i, j)
total_assumps = list()
for a in or_assumps:
total_assumps.append(assumpts + assumps2 + a)
#res, pot, orass = self.test_and_add_or_assumptions(total_assumps)
res, pot = self.test_and_add_or_assumptions(total_assumps)
if res == result.not_possible: return None
ret = self.get_next_table(i, j, pot)
return ret
def set(self, limits, free, target_free, target, basis, assumptions):
er = self.check(limits, free, target_free, target, basis, assumptions)
if not (isinstance(er, bool) and er == True):
return er
self.root_table = simplex.simplex_table()
self.root_table.limits = limits
self.root_table.free = free
self.root_table.target_free = target_free
self.root_table.target = target
self.root_table.basis = basis
self.root_table.amount_of_vars = len(target)
self.root_table.amount_of_equations = len(free)
for i in free:
assumptions.append(assumption(i, '>', parse_expr('0')))
res, pot = self.root_table.test_and_add_assumptions(assumptions)
self.root_table.pots = pot
def get_next_tables_by_row(self, j, assumps):
for i in range(self.amount_of_equations):
#if j in self.basis: continue
assumps2 = list()
assumps2.append(assumption(self.limits[i][j], '>', Number(0)))
or_assumps = self.prepare_or_assumptions(i, j)
total_assumps = list()
for a in or_assumps:
total_assumps.append(assumps + assumps2 + a)
#res, pot, orass = self.test_and_add_or_assumptions(total_assumps)
res, pot = self.test_and_add_or_assumptions(total_assumps)
if res == result.not_possible: continue
ret = self.get_next_table(i, j, pot)
#ret.debug_assumps = orass
yield ret
def set_from_yaml(self, filename):
try:
cfg = yaml.load(open(filename))
except:
raise 'cannot load or parse: ' + filename
if 'matrix' not in cfg:
raise('no matrix in file: ' + filename)
limits = []
for row in cfg['matrix']:
temp = []
for column in row:
temp.append(parse_expr(str(column)))
limits.append(temp)
if 'free' not in cfg:
raise('no free in file: ' + filename)
free = []
for e in cfg['free']:
free.append(parse_expr(str(e)))
if 'target' not in cfg or len(cfg['target']) < 2:
raise('no valid target in file: ' + filename)
target_free = parse_expr(str(cfg['target'][0]))
target = []
for e in cfg['target'][1:]:
target.append(parse_expr(str(e)))
if 'basis' not in cfg:
raise('no basis in file: ' + filename)
basis = cfg['basis']
assumptions = []
if 'assumptions' in cfg:
for a, b, c in cfg['assumptions']:
assumptions.append(assumption(parse_expr(str(a)), b, parse_expr(str(c))))
self.set(limits, free, target_free, target, basis, assumptions)
print(decompose(assumption(linear(4)*linear('x')*linear('x')*linear('x') , '<', linear(2))))
print(decompose(assumption(linear(4)*linear('x')*linear('x')*linear('x') , '<', linear(-2))))"""
a = Number(-1)
b = Number(20)
c = Number(11)
d = Number(-100)
x = Symbol("x")
"""print(decompose(assumption(a*x*x*x + b*x*x + c*x + d, '>', linear(0.))))
print(decompose(assumption(a*x*x*x + b*x*x + c*x + d, '>=', linear(0.))))
print(decompose(assumption(a*x*x*x + b*x*x + c*x + d, '<', linear(0.))))
print(decompose(assumption(a*x*x*x + b*x*x + c*x + d, '<=', linear(0.))))"""
a = Number(1)
b = Number(2000)
c = Number(1999)
print(decompose(assumption(a * x * x + b * x + c, ">", Number(0.0))))
print(decompose(assumption(a * x * x + b * x + c, ">=", Number(0.0))))
print(decompose(assumption(a * x * x + b * x + c, "<", Number(0.0))))
print(decompose(assumption(a * x * x + b * x + c, "<=", Number(0.0))))
a = Number(-1)
b = Number(-1999)
c = Number(2000)
print(decompose(assumption(a * x * x + b * x + c, ">", Number(0.0))))
print(decompose(assumption(a * x * x + b * x + c, ">=", Number(0.0))))
print(decompose(assumption(a * x * x + b * x + c, "<", Number(0.0))))
print(decompose(assumption(a * x * x + b * x + c, "<=", Number(0.0))))
a = Number(1)
b = Number(0)
c = Number(0)
def assumption_signed_ratio_to_linear(assumpt, pot):
variations = variations_for_pot(pot)
num_possible_neg_mults = list()
num_possible_zero_mults = list()
denom_mults = list()
denom_possible_zero = list()
assumpt.exp = assumpt.exp.simplify()
(num, denom) = assumpt.exp.as_numer_denom()
if num.is_number and denom.is_number:
if denom.is_zero:
return variations.get_linear_assumption_list()
if num.is_zero:
if assumpt.sign == '>': return variations.get_linear_assumption_list()
else: return variations.add_assumption(assumption(Number(0), '==', Number(0)))
sign = 1
if num.is_negative: sign *= -1
if denom.is_negative: sign *= -1
variations.add_assumption(assumption(Number(sign), assumpt.sign, Number(0)))
return variations.get_linear_assumption_list()
sign = 1
if not num.is_number:
coef, other = num.combsimp().as_coeff_mul()
if coef.is_negative: sign *= -1
for o in other:
ods = o.as_powers_dict()
for od in ods:
if ods[od].is_even:
num_possible_zero_mults.append(od)
else:
num_possible_neg_mults.append(od)
elif num.is_negative: sign *= -1
if not denom.is_number:
coef, other = denom.combsimp().as_coeff_mul()
if coef.is_negative: sign *= -1
for o in other:
ods = o.as_powers_dict()
for od in ods:
if ods[od].is_even:
denom_possible_zero.append(od)
else:
denom_mults.append(od)
elif denom.is_negative: sign *= -1
if assumpt.sign == '>': strong_sign = True
else: strong_sign = False
global_assumpts = list()
for dpz in denom_possible_zero + denom_mults:
global_assumpts.append(assumption(dpz, '!=', Number(0)))
if strong_sign == False and len(num_possible_zero_mults) > 0:
for npzm in num_possible_zero_mults:
if not variations.add_assumption(assumption(npzm, '==', Number(0))):
continue
if not variations.add_assumptions(global_assumpts):
continue
variations.new_variation()
s = len(num_possible_neg_mults) + len(denom_mults)
if s == 0: return variations.get_linear_assumption_list()
if sign > 0: all_signs = get_signs(s, 0)
else: all_signs = get_signs(s, 1)
for signs in all_signs:
num_signs = signs[:len(num_possible_neg_mults)]
denom_signs = signs[len(num_possible_neg_mults):]
bad_variation = False
for (m, s) in zip(num_possible_neg_mults, num_signs):
if not strong_sign:
if s == '>': s = '>='
else: s = '<='
if not variations.add_assumption(assumption(m, s, Number(0))):
bad_variation = True
break
if bad_variation: continue
for (m, s) in zip(denom_mults, denom_signs):
if not variations.add_assumption(assumption(m, s, Number(0))):
bad_variation = True
break
if bad_variation: continue
if not variations.add_assumptions(global_assumpts):
continue
variations.new_variation()
return variations.get_linear_assumption_list()
def prepare_or_assumptions(self, i, j):
non_alternate = list()
alternate1 = list()
alternate2 = list()
for e in range(i):
assumpts1 = [assumption(self.limits[e][j], '>', Number(0)),
assumption(self.free[i] / self.limits[i][j] ,'<=', self.free[e] / self.limits[e][j]) ]
possib1, assumpts1 = _filter_possible(assumpts1)
assumpts2 = [ assumption(self.limits[e][j], '<=', Number(0)) ]
possib2, assumpts2 = _filter_possible(assumpts2)
if possib1 == result.correct:
if possib2 != result.not_possible:
raise "WTF?"
else:
continue
elif possib2 == result.correct:
if possib1 != result.not_possible:
raise "WTF?"
else:
continue
elif possib1 == result.possible and possib2 == result.possible:
alternate1.append( assumpts1 )
alternate2.append( assumpts2 )
elif possib1 == result.possible:
non_alternate.extend( assumpts1 )
elif possib2 == result.possible:
non_alternate.extend( assumpts2 )
elif possib1 == result.not_possible and possib2 == result.not_possible:
return list()
else:
raise "WTF?"
for e in range(i + 1, self.amount_of_equations):
assumpts1 = [assumption(self.limits[e][j], '>', Number(0)),
assumption(self.free[i] / self.limits[i][j] ,'<', self.free[e] / self.limits[e][j]) ]
possib1, assumpts1 = _filter_possible(assumpts1)
assumpts2 = [ assumption(self.limits[e][j], '<=', Number(0)) ]
possib2, assumpts2 = _filter_possible(assumpts2)
if possib1 == result.correct:
if possib2 != result.not_possible:
raise "WTF?"
else:
continue
elif possib2 == result.correct:
if possib1 != result.not_possible:
raise "WTF?"
else:
continue
elif possib1 == result.possible and possib2 == result.possible:
alternate1.append( assumpts1 )
alternate2.append( assumpts2 )
elif possib1 == result.possible:
non_alternate.extend( assumpts1 )
elif possib2 == result.possible:
non_alternate.extend( assumpts2 )
elif possib1 == result.not_possible and possib2 == result.not_possible:
return list()
else:
raise "WTF?"
or_assumps = list()
size = len(alternate1)
if size == 0:
or_assumps.append(non_alternate)
return or_assumps
s = "{0:0>" + str(size) + "b}"
for i in range(0, 2**size):
ret = list(s.format(i))
current = list()
for i, r in enumerate(ret):
if r == '0': current += deepcopy(alternate1[i])
else: current += deepcopy(alternate2[i])
current.extend(deepcopy(non_alternate))
or_assumps.append(current)
#or_assumps = [deepcopy(non_alternate) + l for l in _or_assumps]
return or_assumps
