def __init__(self, rules):
"""Compile rules into internal lookup tables"""
if isinstance(rules, basestring):
rules = rules.splitlines()
# --- parse and process rules ---
P = Prover()
for rule in rules:
# XXX `a` is hardcoded to be always atom
a, op, b = rule.split(None, 2)
a = Logic.fromstring(a)
b = Logic.fromstring(b)
if op == '->':
P.process_rule(a, b)
elif op == '==':
P.process_rule(a, b)
P.process_rule(b, a)
else:
raise ValueError('unknown op %r' % op)
# --- build deduction networks ---
self.beta_rules = []
for bcond, bimpl in P.rules_beta:
self.beta_rules.append(
(set(_as_pair(a) for a in bcond.args), _as_pair(bimpl)))
# deduce alpha implications
impl_a = deduce_alpha_implications(P.rules_alpha)
# now:
# - apply beta rules to alpha chains (static extension), and
# - further associate beta rules to alpha chain (for inference at runtime)
impl_ab = apply_beta_to_alpha_route(impl_a, P.rules_beta)
# extract defined fact names
self.defined_facts = set(_base_fact(k) for k in impl_ab.keys())
# build rels (forward chains)
full_implications = defaultdict(set)
beta_triggers = defaultdict(set)
for k, (impl, betaidxs) in impl_ab.iteritems():
full_implications[_as_pair(k)] = set(_as_pair(i) for i in impl)
beta_triggers[_as_pair(k)] = betaidxs
self.full_implications = full_implications
self.beta_triggers = beta_triggers
# build prereq (backward chains)
prereq = defaultdict(set)
rel_prereq = rules_2prereq(full_implications)
for k, pitems in rel_prereq.iteritems():
prereq[k] |= pitems
self.prereq = prereq
def __init__(self, rules):
"""Compile rules into internal lookup tables"""
if isinstance(rules, basestring):
rules = rules.splitlines()
# --- parse and process rules ---
P = Prover()
for rule in rules:
# XXX `a` is hardcoded to be always atom
a, op, b = rule.split(None, 2)
a = Logic.fromstring(a)
b = Logic.fromstring(b)
if op == '->':
P.process_rule(a, b)
elif op == '==':
P.process_rule(a, b)
P.process_rule(b, a)
else:
raise ValueError('unknown op %r' % op)
# --- build deduction networks ---
self.beta_rules = []
for bcond, bimpl in P.rules_beta:
self.beta_rules.append(
(set(_as_pair(a) for a in bcond.args), _as_pair(bimpl)))
# deduce alpha implications
impl_a = deduce_alpha_implications(P.rules_alpha)
# now:
# - apply beta rules to alpha chains (static extension), and
# - further associate beta rules to alpha chain (for inference at runtime)
impl_ab = apply_beta_to_alpha_route(impl_a, P.rules_beta)
# extract defined fact names
self.defined_facts = set(_base_fact(k) for k in impl_ab.keys())
# build rels (forward chains)
full_implications = defaultdict(set)
beta_triggers = defaultdict(set)
for k, (impl, betaidxs) in impl_ab.iteritems():
full_implications[_as_pair(k)] = set(_as_pair(i) for i in impl)
beta_triggers[_as_pair(k)] = betaidxs
self.full_implications = full_implications
self.beta_triggers = beta_triggers
# build prereq (backward chains)
prereq = defaultdict(set)
rel_prereq = rules_2prereq(full_implications)
for k, pitems in rel_prereq.iteritems():
prereq[k] |= pitems
self.prereq = prereq
def __init__(self, rules):
"""Compile rules into internal lookup tables"""
if isinstance(rules, basestring):
rules = rules.splitlines()
# --- parse and process rules ---
P = Prover()
for rule in rules:
# XXX `a` is hardcoded to be always atom
a, op, b = rule.split(None, 2)
a = Logic.fromstring(a)
b = Logic.fromstring(b)
if op == '->':
P.process_rule(a, b)
elif op == '==':
P.process_rule(a, b)
P.process_rule(b, a)
else:
raise ValueError('unknown op %r' % op)
#P.print_proved('RULES')
#P.print_beta('BETA-RULES')
# --- build deduction networks ---
# deduce alpha implications
impl_a = deduce_alpha_implications(P.rules_alpha)
# now:
# - apply beta rules to alpha chains (static extension), and
# - further associate beta rules to alpha chain (for inference at runtime)
impl_ab = apply_beta_to_alpha_route(impl_a, P.rules_beta)
if 0:
print '\n --- ALPHA-CHAINS (I) ---'
for a,b in impl_a.iteritems():
print '%s\t-> α(%2i):%s' % (a,len(b),b)
print ' - - - - - '
print
if 0:
print '\n --- ALPHA-CHAINS (II) ---'
for a,(b,bb) in impl_ab.iteritems():
print '%s\t-> α(%2i):%s β(%s)' % (a,len(b),b, ' '.join(str(x) for x in bb))
print ' - - - - - '
print
# extract defined fact names
self.defined_facts = set()
for k in impl_ab.keys():
if k[:1] == '!':
k = k[1:]
self.defined_facts.add(k)
#print 'defined facts: (%2i) %s' % (len(self.defined_facts), self.defined_facts)
# now split each rule into four logic chains
# (removing betaidxs from impl_ab view) (XXX is this needed?)
impl_ab_ = dict( (k,impl) for k, (impl,betaidxs) in impl_ab.iteritems())
rel_tt, rel_tf, rel_ft, rel_ff = split_rules_tt_tf_ft_ff(impl_ab_)
# XXX merge me with split_rules_tt_tf_ft_ff ?
rel_tbeta = {}
rel_fbeta = {}
for k, (impl,betaidxs) in impl_ab.iteritems():
if k[:1] == '!':
rel_xbeta = rel_fbeta
k = name_not(k)
else:
rel_xbeta = rel_tbeta
rel_xbeta[k] = betaidxs
self.rel_tt = rel_tt
self.rel_tf = rel_tf
self.rel_tbeta = rel_tbeta
self.rel_ff = rel_ff
self.rel_ft = rel_ft
self.rel_fbeta = rel_fbeta
self.beta_rules = P.rules_beta
# build rels (forward chains)
K = set (rel_tt.keys())
K.update(rel_tf.keys())
K.update(rel_ff.keys())
K.update(rel_ft.keys())
rels = {}
empty= ()
for k in K:
tt = rel_tt.get(k,empty)
tf = rel_tf.get(k,empty)
ft = rel_ft.get(k,empty)
ff = rel_ff.get(k,empty)
tbeta = rel_tbeta.get(k,empty)
fbeta = rel_fbeta.get(k,empty)
rels[k] = tt, tf, tbeta, ft, ff, fbeta
self.rels = rels
# build prereq (backward chains)
prereq = {}
for rel in [rel_tt, rel_tf, rel_ff, rel_ft]:
rel_prereq = rules_2prereq(rel)
for k,pitems in rel_prereq.iteritems():
kp = prereq.setdefault(k,[])
for p in pitems:
list_populate(kp, p)
self.prereq = prereq
def __init__(self, rules):
"""Compile rules into internal lookup tables"""
if isinstance(rules, basestring):
rules = rules.splitlines()
# --- parse and process rules ---
P = Prover()
for rule in rules:
# XXX `a` is hardcoded to be always atom
a, op, b = rule.split(None, 2)
a = Logic.fromstring(a)
b = Logic.fromstring(b)
if op == '->':
P.process_rule(a, b)
elif op == '==':
P.process_rule(a, b)
P.process_rule(b, a)
else:
raise ValueError('unknown op %r' % op)
# --- build deduction networks ---
# deduce alpha implications
impl_a = deduce_alpha_implications(P.rules_alpha)
# now:
# - apply beta rules to alpha chains (static extension), and
# - further associate beta rules to alpha chain (for inference at runtime)
impl_ab = apply_beta_to_alpha_route(impl_a, P.rules_beta)
# extract defined fact names
self.defined_facts = set()
for k in impl_ab.keys():
if k[:1] == '!':
k = k[1:]
self.defined_facts.add(k)
# now split each rule into four logic chains
# (removing betaidxs from impl_ab view) (XXX is this needed?)
impl_ab_ = dict(
(k, impl) for k, (impl, betaidxs) in impl_ab.iteritems())
rel_tt, rel_tf, rel_ft, rel_ff = split_rules_tt_tf_ft_ff(impl_ab_)
rel_tbeta = {}
rel_fbeta = {}
for k, (impl, betaidxs) in impl_ab.iteritems():
if k[:1] == '!':
rel_xbeta = rel_fbeta
k = name_not(k)
else:
rel_xbeta = rel_tbeta
rel_xbeta[k] = betaidxs
self.rel_tt = rel_tt
self.rel_tf = rel_tf
self.rel_tbeta = rel_tbeta
self.rel_ff = rel_ff
self.rel_ft = rel_ft
self.rel_fbeta = rel_fbeta
self.beta_rules = P.rules_beta
# build rels (forward chains)
K = set(rel_tt.keys())
K.update(rel_tf.keys())
K.update(rel_ff.keys())
K.update(rel_ft.keys())
rels = {}
empty = ()
for k in K:
tt = rel_tt.get(k, empty)
tf = rel_tf.get(k, empty)
ft = rel_ft.get(k, empty)
ff = rel_ff.get(k, empty)
tbeta = rel_tbeta.get(k, empty)
fbeta = rel_fbeta.get(k, empty)
rels[k] = tt, tf, tbeta, ft, ff, fbeta
self.rels = rels
# build prereq (backward chains)
prereq = {}
for rel in [rel_tt, rel_tf, rel_ff, rel_ft]:
rel_prereq = rules_2prereq(rel)
for k, pitems in rel_prereq.iteritems():
kp = prereq.setdefault(k, [])
for p in pitems:
list_populate(kp, p)
self.prereq = prereq
def __init__(self, rules):
"""Compile rules into internal lookup tables"""
if isinstance(rules, basestring):
rules = rules.splitlines()
# --- parse and process rules ---
P = Prover()
for rule in rules:
# XXX `a` is hardcoded to be always atom
a, op, b = rule.split(None, 2)
a = Logic.fromstring(a)
b = Logic.fromstring(b)
if op == '->':
P.process_rule(a, b)
elif op == '==':
P.process_rule(a, b)
P.process_rule(b, a)
else:
raise ValueError('unknown op %r' % op)
# --- build deduction networks ---
# deduce alpha implications
impl_a = deduce_alpha_implications(P.rules_alpha)
# now:
# - apply beta rules to alpha chains (static extension), and
# - further associate beta rules to alpha chain (for inference at runtime)
impl_ab = apply_beta_to_alpha_route(impl_a, P.rules_beta)
# extract defined fact names
self.defined_facts = set()
for k in impl_ab.keys():
if k[:1] == '!':
k = k[1:]
self.defined_facts.add(k)
# now split each rule into four logic chains
# (removing betaidxs from impl_ab view) (XXX is this needed?)
impl_ab_ = dict( (k,impl) for k, (impl,betaidxs) in impl_ab.iteritems())
rel_tt, rel_tf, rel_ft, rel_ff = split_rules_tt_tf_ft_ff(impl_ab_)
rel_tbeta = {}
rel_fbeta = {}
for k, (impl,betaidxs) in impl_ab.iteritems():
if k[:1] == '!':
rel_xbeta = rel_fbeta
k = name_not(k)
else:
rel_xbeta = rel_tbeta
rel_xbeta[k] = betaidxs
self.rel_tt = rel_tt
self.rel_tf = rel_tf
self.rel_tbeta = rel_tbeta
self.rel_ff = rel_ff
self.rel_ft = rel_ft
self.rel_fbeta = rel_fbeta
self.beta_rules = P.rules_beta
# build rels (forward chains)
K = set (rel_tt.keys())
K.update(rel_tf.keys())
K.update(rel_ff.keys())
K.update(rel_ft.keys())
rels = {}
empty= ()
for k in K:
tt = rel_tt[k]
tf = rel_tf[k]
ft = rel_ft[k]
ff = rel_ff[k]
tbeta = rel_tbeta.get(k,empty)
fbeta = rel_fbeta.get(k,empty)
rels[k] = tt, tf, tbeta, ft, ff, fbeta
self.rels = rels
# build prereq (backward chains)
prereq = defaultdict(set)
for rel in [rel_tt, rel_tf, rel_ff, rel_ft]:
rel_prereq = rules_2prereq(rel)
for k, pitems in rel_prereq.iteritems():
prereq[k] |= pitems
self.prereq = prereq
