def get_events(seq):
events = set()
if seq.optional:
logger('skipped optional rule {}', seq)
return events
free_vars = seq.vars
for sequent in normalize(seq):
for antecedent in sequent.antecedents:
if antecedent.name == 'EQUAL':
lhs, rhs = antecedent.args
assert lhs.is_var() and rhs.is_var(), antecedent
# HACK ignore equation antecedents
else:
events.add(antecedent)
# HACK to deal with Equation args
succedent = iter(sequent.succedents).next()
for arg in succedent.args:
if not arg.is_var():
events.add(arg)
antecedent_vars = union(a.vars for a in sequent.antecedents)
for var in succedent.vars & free_vars - antecedent_vars:
compound_count = sum(1 for arg in succedent.args if arg.args)
in_count = sum(1 for arg in succedent.args if var in arg.vars)
# if the var is in a compound in both succedent.args,
# then succedent.args are sufficient events.
if in_count < 2 or compound_count < 2:
events.add(var)
return events
def compile_full(seq):
results = []
if seq.optional:
logger('skipped optional rule {}', seq)
return results
for derived_seq in normalize(seq):
context = frozenset()
bound = frozenset()
results.append(optimize_given(derived_seq, context, bound))
assert results, 'failed to compile {0}'.format(seq)
logger('derived {} rules from {}', len(results), seq)
return results
def compile_full(seq):
results = []
if seq.optional:
logger('skipped optional rule {0}'.format(seq))
return results
for part in normalize(seq):
context = set()
bound = set()
ranked = rank_compiled(part, context, bound)
results.append(min(ranked))
assert results, 'failed to compile {0}'.format(seq)
logger('derived {0} rules from {1}'.format(len(results), seq))
return results
def _test_normalize(name):
print '# normalized'
print
for rule in RULE_SETS[name]:
print rule.ascii()
print
if len(rule.succedents) != 1:
print ' TODO'
print
continue
for seq in sequents.normalize(rule):
print seq.ascii(indent=4)
print
sequents.assert_normal(seq)
def normalize_given(seq, atom, bound):
for normal in normalize(seq):
if atom in normal.antecedents or atom.is_var():
yield normal
# HACK to deal with Equation args
succedent = iter(normal.succedents).next()
if succedent.name == 'EQUAL':
lhs, rhs = succedent.args
if lhs == atom:
yield Sequent(
set_with(normal.antecedents, lhs),
set([Expression('EQUAL', lhs.var, rhs)]))
elif rhs == atom:
yield Sequent(
set_with(normal.antecedents, rhs),
set([Expression('EQUAL', lhs, rhs.var)]))
