def test_FactRules_deduce2():
# pos/neg/zero, but the rules are not sufficient to derive all relations
f = FactRules(["pos -> !neg", "pos -> !z"])
def D(facts):
kb = FactKB(f)
kb.deduce_all_facts(facts)
return kb
assert D({"pos": T}) == {"pos": T, "neg": F, "z": F}
assert D({"pos": F}) == {"pos": F}
assert D({"neg": T}) == {"pos": F, "neg": T}
assert D({"neg": F}) == {"neg": F}
assert D({"z": T}) == {"pos": F, "z": T}
assert D({"z": F}) == {"z": F}
# pos/neg/zero. rules are sufficient to derive all relations
f = FactRules(["pos -> !neg", "neg -> !pos", "pos -> !z", "neg -> !z"])
assert D({"pos": T}) == {"pos": T, "neg": F, "z": F}
assert D({"pos": F}) == {"pos": F}
assert D({"neg": T}) == {"pos": F, "neg": T, "z": F}
assert D({"neg": F}) == {"neg": F}
assert D({"z": T}) == {"pos": F, "neg": F, "z": T}
assert D({"z": F}) == {"z": F}
def test_FactRules_deduce2():
# pos/neg/zero, but the rules are not sufficient to derive all relations
f = FactRules(['pos -> !neg', 'pos -> !z'])
def D(facts):
kb = FactKB(f)
kb.deduce_all_facts(facts)
return kb
assert D({'pos': T}) == {'pos': T, 'neg': F, 'z': F}
assert D({'pos': F}) == {'pos': F }
assert D({'neg': T}) == {'pos': F, 'neg': T }
assert D({'neg': F}) == { 'neg': F }
assert D({'z': T}) == {'pos': F, 'z': T}
assert D({'z': F}) == { 'z': F}
# pos/neg/zero. rules are sufficient to derive all relations
f = FactRules(['pos -> !neg', 'neg -> !pos', 'pos -> !z', 'neg -> !z'])
assert D({'pos': T}) == {'pos': T, 'neg': F, 'z': F}
assert D({'pos': F}) == {'pos': F }
assert D({'neg': T}) == {'pos': F, 'neg': T, 'z': F}
assert D({'neg': F}) == { 'neg': F }
assert D({'z': T}) == {'pos': F, 'neg': F, 'z': T}
assert D({'z': F}) == { 'z': F}
def test_FactRules_parse():
f = FactRules('a -> b')
assert f.rel_tt == {'a': set(['b']), 'b': set([])}
assert f.rel_tf == {'a': set([]), 'b': set([])}
assert f.rel_ff == {'b': set(['a']), 'a': set([])}
assert f.rel_ft == {'a': set([]), 'b': set([])}
assert f.prereq == {'b': set(['a']), 'a': set(['b'])}
f = FactRules('a -> !b')
assert f.rel_tt == {'a': set([]), 'b': set([])}
assert f.rel_tf == {'a': set(['b']), 'b': set(['a'])}
assert f.rel_ff == {'a': set([]), 'b': set([])}
assert f.rel_ft == {'a': set([]), 'b': set([])}
assert f.prereq == {'b': set(['a']), 'a': set(['b'])}
f = FactRules('!a -> b')
assert f.rel_tt == {'a': set([]), 'b': set([])}
assert f.rel_tf == {'a': set([]), 'b': set([])}
assert f.rel_ff == {'a': set([]), 'b': set([])}
assert f.rel_ft == {'a': set(['b']), 'b': set(['a'])}
assert f.prereq == {'b': set(['a']), 'a': set(['b'])}
f = FactRules('!a -> !b')
assert f.rel_tt == {'a': set([]), 'b': set(['a'])}
assert f.rel_tf == {'a': set([]), 'b': set([])}
assert f.rel_ff == {'a': set(['b']), 'b': set([])}
assert f.rel_ft == {'a': set([]), 'b': set([])}
assert f.prereq == {'b': set(['a']), 'a': set(['b'])}
f = FactRules('!z == nz')
assert f.rel_tt == {'z': set([]), 'nz': set([])}
assert f.rel_tf == {'nz': set(['z']), 'z': set(['nz'])}
assert f.rel_ff == {'z': set([]), 'nz': set([])}
assert f.rel_ft == {'nz': set(['z']), 'z': set(['nz'])}
assert f.prereq == {'z': set(['nz']), 'nz': set(['z'])}
def test_FactRules_parse():
f = FactRules("a -> b")
assert f.prereq == {"b": set(["a"]), "a": set(["b"])}
f = FactRules("a -> !b")
assert f.prereq == {"b": set(["a"]), "a": set(["b"])}
f = FactRules("!a -> b")
assert f.prereq == {"b": set(["a"]), "a": set(["b"])}
f = FactRules("!a -> !b")
assert f.prereq == {"b": set(["a"]), "a": set(["b"])}
f = FactRules("!z == nz")
assert f.prereq == {"z": set(["nz"]), "nz": set(["z"])}
def test_FactRules_parse():
f = FactRules('a -> b')
assert f.prereq == {'b': {'a'}, 'a': {'b'}}
f = FactRules('a -> !b')
assert f.prereq == {'b': {'a'}, 'a': {'b'}}
f = FactRules('!a -> b')
assert f.prereq == {'b': {'a'}, 'a': {'b'}}
f = FactRules('!a -> !b')
assert f.prereq == {'b': {'a'}, 'a': {'b'}}
f = FactRules('!z == nz')
assert f.prereq == {'z': {'nz'}, 'nz': {'z'}}
def test_FactRules_deduce_multiple2():
f = FactRules(['real == neg | zero | pos'])
def D(facts):
kb = FactKB(f)
kb.deduce_all_facts(facts)
return kb
assert D({'real': T}) == {'real': T}
assert D({'real': F}) == {'real': F, 'neg': F, 'zero': F, 'pos': F}
assert D({'neg': T}) == {'real': T, 'neg': T}
assert D({'zero': T}) == {'real': T, 'zero': T}
assert D({'pos': T}) == {'real': T, 'pos': T}
# --- key tests below ---
assert D({'neg': F, 'zero': F, 'pos': F}) == {'real': F, 'neg': F,
'zero': F, 'pos': F}
assert D({'real': T, 'neg': F}) == {'real': T, 'neg': F}
assert D({'real': T, 'zero': F}) == {'real': T, 'zero': F}
assert D({'real': T, 'pos': F}) == {'real': T, 'pos': F}
assert D({'real': T, 'zero': F, 'pos': F}) == {'real': T,
'neg': T, 'zero': F, 'pos': F}
assert D({'real': T, 'neg': F, 'pos': F}) == {'real': T,
'neg': F, 'zero': T, 'pos': F}
assert D({'real': T, 'neg': F, 'zero': F }) == {'real': T,
'neg': F, 'zero': F, 'pos': T}
assert D({'neg': T, 'zero': F, 'pos': F}) == {'real': T, 'neg': T,
'zero': F, 'pos': F}
assert D({'neg': F, 'zero': T, 'pos': F}) == {'real': T, 'neg': F,
'zero': T, 'pos': F}
assert D({'neg': F, 'zero': F, 'pos': T}) == {'real': T, 'neg': F,
'zero': F, 'pos': T}
def test_FactRules_deduce_multiple2():
f = FactRules(['real == neg | zero | pos'])
D = f.deduce_all_facts
assert D({'real': T}) == {'real': T}
assert D({'real': F}) == {'real': F, 'neg': F, 'zero': F, 'pos': F}
assert D({'neg' : T}) == {'real': T, 'neg': T}
assert D({'zero': T}) == {'real': T, 'zero': T}
assert D({'pos' : T}) == {'real': T, 'pos': T}
# --- key tests below ---
assert D({'neg': F, 'zero': F, 'pos': F}) == {'real': F, 'neg': F, 'zero': F, 'pos': F}
assert D({'real':T, 'neg': F}) == {'real': T, 'neg': F}
assert D({'real':T, 'zero':F}) == {'real': T, 'zero':F}
assert D({'real':T, 'pos': F}) == {'real': T, 'pos': F}
assert D({'real':T, 'zero': F, 'pos': F}) == {'real': T, 'neg': T, 'zero': F, 'pos': F}
assert D({'real':T, 'neg': F, 'pos': F}) == {'real': T, 'neg': F, 'zero': T, 'pos': F}
assert D({'real':T, 'neg': F, 'zero': F }) == {'real': T, 'neg': F, 'zero': F, 'pos': T}
assert D({'neg': T, 'zero': F, 'pos': F}) == {'real': T, 'neg': T, 'zero': F, 'pos': F}
assert D({'neg': F, 'zero': T, 'pos': F}) == {'real': T, 'neg': F, 'zero': T, 'pos': F}
assert D({'neg': F, 'zero': F, 'pos': T}) == {'real': T, 'neg': F, 'zero': F, 'pos': T}
def test_FactRules_deduce_staticext():
# verify that static beta-extensions deduction takes place
f = FactRules(['real == neg | zero | pos',
'neg -> real & !zero & !pos',
'pos -> real & !zero & !neg',
'nneg == real & !neg',
'npos == real & !pos'])
assert ('npos', True) in f.full_implications[('neg', True)]
assert ('nneg', True) in f.full_implications[('pos', True)]
assert ('nneg', True) in f.full_implications[('zero', True)]
assert ('npos', True) in f.full_implications[('zero', True)]
def test_FactRules_deduce_staticext():
# verify that static beta-extensions deduction takes place
f = FactRules([
'real == neg | zero | pos', 'neg -> real & !zero & !pos',
'pos -> real & !zero & !neg', 'nneg == real & !neg',
'npos == real & !pos'
])
assert 'npos' in f.rel_tt['neg']
assert 'nneg' in f.rel_tt['pos']
assert 'nneg' in f.rel_tt['zero']
assert 'npos' in f.rel_tt['zero']
def test_FactRules_deduce2():
# pos/neg/zero, but the rules are not sufficient to derive all relations
f = FactRules(['pos -> !neg', 'pos -> !z'])
D = f.deduce_all_facts
assert D({'pos': T}) == {'pos': T, 'neg': F, 'z': F}
assert D({'pos': F}) == {'pos': F}
assert D({'neg': T}) == {'pos': F, 'neg': T}
assert D({'neg': F}) == {'neg': F}
assert D({'z': T}) == {'pos': F, 'z': T}
assert D({'z': F}) == {'z': F}
# pos/neg/zero. rules are sufficient to derive all relations
f = FactRules(['pos -> !neg', 'neg -> !pos', 'pos -> !z', 'neg -> !z'])
D = f.deduce_all_facts
assert D({'pos': T}) == {'pos': T, 'neg': F, 'z': F}
assert D({'pos': F}) == {'pos': F}
assert D({'neg': T}) == {'pos': F, 'neg': T, 'z': F}
assert D({'neg': F}) == {'neg': F}
assert D({'z': T}) == {'pos': F, 'neg': F, 'z': T}
assert D({'z': F}) == {'z': F}
def test_FactRules_deduce_base():
# deduction that starts from base
f = FactRules(['real == neg | zero | pos',
'neg -> real & !zero & !pos',
'pos -> real & !zero & !neg'])
base = FactKB(f)
base.deduce_all_facts({'real': T, 'neg': F})
assert base == {'real': T, 'neg': F}
base.deduce_all_facts({'zero': F})
assert base == {'real': T, 'neg': F, 'zero': F, 'pos': T}
def test_FactRules_deduce_staticext():
# verify that static beta-extensions deduction takes place
f = FactRules([
"real == neg | zero | pos",
"neg -> real & !zero & !pos",
"pos -> real & !zero & !neg",
"nneg == real & !neg",
"npos == real & !pos",
])
assert ("npos", True) in f.full_implications[("neg", True)]
assert ("nneg", True) in f.full_implications[("pos", True)]
assert ("nneg", True) in f.full_implications[("zero", True)]
assert ("npos", True) in f.full_implications[("zero", True)]
def test_FactRules_parse():
f = FactRules('a -> b')
# assert f.negs == {}
assert f.rel_tt == {'a': ['b']}
assert f.rel_tf == {}
assert f.rel_ff == {'b': ['a']}
assert f.rel_ft == {}
assert f.prereq == {'b': ['a'], 'a': ['b']}
f = FactRules('a -> !b')
assert f.rel_tt == {}
assert f.rel_tf == {'a': ['b'], 'b': ['a']}
assert f.rel_ff == {}
assert f.rel_ft == {}
assert f.prereq == {'b': ['a'], 'a': ['b']}
f = FactRules('!a -> b')
assert f.rel_tt == {}
assert f.rel_tf == {}
assert f.rel_ff == {}
assert f.rel_ft == {'a': ['b'], 'b': ['a']}
assert f.prereq == {'b': ['a'], 'a': ['b']}
f = FactRules('!a -> !b')
assert f.rel_tt == {'b': ['a']}
assert f.rel_tf == {}
assert f.rel_ff == {'a': ['b']}
assert f.rel_ft == {}
assert f.prereq == {'b': ['a'], 'a': ['b']}
f = FactRules('!z == nz')
assert f.rel_tt == {}
assert f.rel_tf == {'nz': ['z'], 'z': ['nz']}
assert f.rel_ff == {}
assert f.rel_ft == {'nz': ['z'], 'z': ['nz']}
assert f.prereq == {'z': ['nz'], 'nz': ['z']}
def test_FactRules_deduce_base():
# deduction that starts from base
f = FactRules([
"real == neg | zero | pos",
"neg -> real & !zero & !pos",
"pos -> real & !zero & !neg",
])
base = FactKB(f)
base.deduce_all_facts({"real": T, "neg": F})
assert base == {"real": T, "neg": F}
base.deduce_all_facts({"zero": F})
assert base == {"real": T, "neg": F, "zero": F, "pos": T}
def test_FactRules_deduce_base():
# deduction that starts from base
f = FactRules(['real == neg | zero | pos',
'neg -> real & !zero & !pos',
'pos -> real & !zero & !neg'])
D = f.deduce_all_facts
base = D({'real': T, 'neg': F})
assert base == {'real': T, 'neg': F}
X = D({'zero': F}, base=base)
assert X is base # base is modified inplace
assert base == {'real': T, 'neg': F, 'zero': F, 'pos': T}
def test_FactRules_deduce():
f = FactRules(['a -> b', 'b -> c', 'b -> d', 'c -> e'])
D = f.deduce_all_facts
assert D({'a': T}) == {'a': T, 'b': T, 'c': T, 'd': T, 'e': T}
assert D({'b': T}) == {'b': T, 'c': T, 'd': T, 'e': T}
assert D({'c': T}) == {'c': T, 'e': T}
assert D({'d': T}) == {'d': T}
assert D({'e': T}) == {'e': T}
assert D({'a': F}) == {'a': F}
assert D({'b': F}) == {'a': F, 'b': F}
assert D({'c': F}) == {'a': F, 'b': F, 'c': F}
assert D({'d': F}) == {'a': F, 'b': F, 'd': F}
assert D({'a': U}) == {'a': U} # XXX ok?
def test_FactRules_deduce_multiple():
# deduction that involves _several_ starting points
# TODO add the same check for 'npos == real & !pos' ?
f = FactRules(['real == pos | npos'])
D = f.deduce_all_facts
assert D({'real': T}) == {'real': T}
assert D({'real': F}) == {'real': F, 'pos': F, 'npos': F}
assert D({'pos': T}) == {'real': T, 'pos': T}
assert D({'npos': T}) == {'real': T, 'npos': T}
# --- key tests below ---
assert D({'pos': F, 'npos': F}) == {'real': F, 'pos': F, 'npos': F}
assert D({'real': T, 'pos': F}) == {'real': T, 'pos': F, 'npos': T}
assert D({'real': T, 'npos': F}) == {'real': T, 'pos': T, 'npos': F}
assert D({'pos': T, 'npos': F}) == {'real': T, 'pos': T, 'npos': F}
assert D({'pos': F, 'npos': T}) == {'real': T, 'pos': F, 'npos': T}
def test_FactRules_deduce():
f = FactRules(["a -> b", "b -> c", "b -> d", "c -> e"])
def D(facts):
kb = FactKB(f)
kb.deduce_all_facts(facts)
return kb
assert D({"a": T}) == {"a": T, "b": T, "c": T, "d": T, "e": T}
assert D({"b": T}) == {"b": T, "c": T, "d": T, "e": T}
assert D({"c": T}) == {"c": T, "e": T}
assert D({"d": T}) == {"d": T}
assert D({"e": T}) == {"e": T}
assert D({"a": F}) == {"a": F}
assert D({"b": F}) == {"a": F, "b": F}
assert D({"c": F}) == {"a": F, "b": F, "c": F}
assert D({"d": F}) == {"a": F, "b": F, "d": F}
assert D({"a": U}) == {"a": U} # XXX ok?
def test_FactRules_deduce():
f = FactRules(['a -> b', 'b -> c', 'b -> d', 'c -> e'])
def D(facts):
kb = FactKB(f)
kb.deduce_all_facts(facts)
return kb
assert D({'a': T}) == {'a': T, 'b': T, 'c': T, 'd': T, 'e': T}
assert D({'b': T}) == { 'b': T, 'c': T, 'd': T, 'e': T}
assert D({'c': T}) == { 'c': T, 'e': T}
assert D({'d': T}) == { 'd': T }
assert D({'e': T}) == { 'e': T}
assert D({'a': F}) == {'a': F }
assert D({'b': F}) == {'a': F, 'b': F }
assert D({'c': F}) == {'a': F, 'b': F, 'c': F }
assert D({'d': F}) == {'a': F, 'b': F, 'd': F }
assert D({'a': U}) == {'a': U} # XXX ok?
def test_FactRules_deduce_multiple():
# deduction that involves _several_ starting points
f = FactRules(["real == pos | npos"])
def D(facts):
kb = FactKB(f)
kb.deduce_all_facts(facts)
return kb
assert D({"real": T}) == {"real": T}
assert D({"real": F}) == {"real": F, "pos": F, "npos": F}
assert D({"pos": T}) == {"real": T, "pos": T}
assert D({"npos": T}) == {"real": T, "npos": T}
# --- key tests below ---
assert D({"pos": F, "npos": F}) == {"real": F, "pos": F, "npos": F}
assert D({"real": T, "pos": F}) == {"real": T, "pos": F, "npos": T}
assert D({"real": T, "npos": F}) == {"real": T, "pos": T, "npos": F}
assert D({"pos": T, "npos": F}) == {"real": T, "pos": T, "npos": F}
assert D({"pos": F, "npos": T}) == {"real": T, "pos": F, "npos": T}
def test_FactRules_deduce_multiple():
# deduction that involves _several_ starting points
f = FactRules(['real == pos | npos'])
def D(facts):
kb = FactKB(f)
kb.deduce_all_facts(facts)
return kb
assert D({'real': T}) == {'real': T}
assert D({'real': F}) == {'real': F, 'pos': F, 'npos': F}
assert D({'pos': T}) == {'real': T, 'pos': T}
assert D({'npos': T}) == {'real': T, 'npos': T}
# --- key tests below ---
assert D({'pos': F, 'npos': F}) == {'real': F, 'pos': F, 'npos': F}
assert D({'real': T, 'pos': F}) == {'real': T, 'pos': F, 'npos': T}
assert D({'real': T, 'npos': F}) == {'real': T, 'pos': T, 'npos': F}
assert D({'pos': T, 'npos': F}) == {'real': T, 'pos': T, 'npos': F}
assert D({'pos': F, 'npos': T}) == {'real': T, 'pos': F, 'npos': T}
def X_test_FactRules_deduce_cow():
f = FactRules(['real == neg | zero | pos',
'neg -> real & !zero & !pos',
'pos -> real & !zero & !neg'])
D = f.deduce_all_facts
base0 = D({'real': T, 'neg': F})
assert base0 == {'real': T, 'neg': F}
base = base0.copy()
X = D({'zero': F}, base=base, cow=False)
assert X is base # base is modified inplace
assert base == {'real': T, 'neg': F, 'zero': F, 'pos': T}
base = base0.copy()
X, new_knowledge = D({'zero': F}, base=base, cow=True)
assert X is not base # base should be copied
assert base == {'real': T, 'neg': F}
assert X == {'real': T, 'neg': F, 'zero': F, 'pos': T}
_assume_rules = FactRules([
'integer -> rational',
'rational -> real',
'real -> complex',
'real -> hermitian',
'imaginary -> complex',
'imaginary -> antihermitian',
'complex -> commutative',
'odd == integer & !even',
'even == integer & !odd',
'real == negative | zero | positive',
'positive -> real & !negative & !zero',
'negative -> real & !positive & !zero',
'nonpositive == real & !positive',
'nonnegative == real & !negative',
'zero -> infinitesimal & even',
'prime -> integer & positive',
'composite == integer & positive & !prime',
'irrational == real & !rational',
'imaginary -> !real',
'!bounded == unbounded',
'noninteger == real & !integer',
'!zero == nonzero',
# XXX do we need this ?
'finite -> bounded', # XXX do we need this?
'finite -> !zero', # XXX wrong?
'infinitesimal -> !finite', # XXX is this ok?
])
_assume_rules = FactRules([
"integer -> rational",
"rational -> real",
"rational -> algebraic",
"algebraic -> complex",
"transcendental == complex & !algebraic",
"real -> hermitian",
"imaginary -> complex",
"imaginary -> antihermitian",
"extended_real -> commutative",
"complex -> commutative",
"complex -> finite",
"odd == integer & !even",
"even == integer & !odd",
"real -> complex",
"extended_real -> real | infinite",
"real == extended_real & finite",
"extended_real == extended_negative | zero | extended_positive",
"extended_negative == extended_nonpositive & extended_nonzero",
"extended_positive == extended_nonnegative & extended_nonzero",
"extended_nonpositive == extended_real & !extended_positive",
"extended_nonnegative == extended_real & !extended_negative",
"real == negative | zero | positive",
"negative == nonpositive & nonzero",
"positive == nonnegative & nonzero",
"nonpositive == real & !positive",
"nonnegative == real & !negative",
"positive == extended_positive & finite",
"negative == extended_negative & finite",
"nonpositive == extended_nonpositive & finite",
"nonnegative == extended_nonnegative & finite",
"nonzero == extended_nonzero & finite",
"zero -> even & finite",
"zero == extended_nonnegative & extended_nonpositive",
"zero == nonnegative & nonpositive",
"nonzero -> real",
"prime -> integer & positive",
"composite -> integer & positive & !prime",
"!composite -> !positive | !even | prime",
"irrational == real & !rational",
"imaginary -> !extended_real",
"infinite -> !finite",
"noninteger == extended_real & !integer",
"extended_nonzero == extended_real & !zero",
])
# irrational -- http://en.wikipedia.org/wiki/Irrational_number
# ...
_assume_rules = FactRules([
'integer -> rational',
'rational -> real',
'real -> complex',
'real -> hermitian',
'imaginary -> complex',
'imaginary -> antihermitian',
'complex -> commutative',
'odd == integer & !even',
'even == integer & !odd',
'real == negative | zero | positive',
'negative == nonpositive & nonzero',
'positive == nonnegative & nonzero',
'zero == nonnegative & nonpositive',
'nonpositive == real & !positive',
'nonnegative == real & !negative',
'zero -> even',
'prime -> integer & positive',
'composite == integer & positive & !prime',
'irrational == real & !rational',
'imaginary -> !real',
'!bounded == unbounded',
'noninteger == real & !integer',
'!zero == nonzero',
])
_assume_defined = _assume_rules.defined_facts.copy()
_assume_defined.add('polar')
_assume_rules = FactRules([
'integer -> rational',
'rational -> real',
'rational -> algebraic',
'algebraic -> complex & finite',
'transcendental == complex & !algebraic & finite',
'real -> hermitian',
'imaginary -> complex & finite',
'imaginary -> antihermitian',
'extended_real -> commutative',
'complex -> commutative',
'complex -> infinite | finite',
'odd == integer & !even',
'even == integer & !odd',
'extended_real -> complex',
'extended_real -> real | infinite',
'real == extended_real & finite',
'extended_real == extended_negative | zero | extended_positive',
'extended_negative == extended_nonpositive & extended_nonzero',
'extended_positive == extended_nonnegative & extended_nonzero',
'extended_nonpositive == extended_real & !extended_positive',
'extended_nonnegative == extended_real & !extended_negative',
'real == negative | zero | positive',
'negative == nonpositive & nonzero',
'positive == nonnegative & nonzero',
'nonpositive == real & !positive',
'nonnegative == real & !negative',
'positive == extended_positive & finite',
'negative == extended_negative & finite',
'nonpositive == extended_nonpositive & finite',
'nonnegative == extended_nonnegative & finite',
'nonzero -> extended_nonzero & finite',
'zero -> even & finite',
'zero == extended_nonnegative & extended_nonpositive',
'zero == nonnegative & nonpositive',
'nonzero -> complex',
'prime -> integer & positive',
'composite -> integer & positive & !prime',
'!composite -> !positive | !even | prime',
'irrational == real & !rational',
'imaginary -> !extended_real',
'infinite -> !finite',
'noninteger == extended_real & !integer',
'extended_nonzero == extended_real & !zero',
'invertible == !singular',
'random -> finite',
'emptyset -> finiteset',
'infiniteset == !finiteset',
'nonemptyset == !emptyset',
])
def test_FactRules_parse2():
raises(ValueError, lambda: FactRules("a -> !a"))
_assume_rules = FactRules([
'integer -> rational',
'rational -> real',
'rational -> algebraic',
'algebraic -> complex',
'real -> complex',
'real -> hermitian',
'imaginary -> complex',
'imaginary -> antihermitian',
'complex -> commutative',
'odd == integer & !even',
'even == integer & !odd',
'real == negative | zero | positive',
'transcendental == complex & !algebraic',
'negative == nonpositive & nonzero',
'positive == nonnegative & nonzero',
'zero == nonnegative & nonpositive',
'nonpositive == real & !positive',
'nonnegative == real & !negative',
'zero -> even & finite',
'prime -> integer & positive',
'composite -> integer & positive & !prime',
'irrational == real & !rational',
'imaginary -> !real',
'infinite -> !finite',
'noninteger == real & !integer',
'nonzero == real & !zero',
])
def test_FactRules_deduce_multiple2():
f = FactRules(["real == neg | zero | pos"])
def D(facts):
kb = FactKB(f)
kb.deduce_all_facts(facts)
return kb
assert D({"real": T}) == {"real": T}
assert D({"real": F}) == {"real": F, "neg": F, "zero": F, "pos": F}
assert D({"neg": T}) == {"real": T, "neg": T}
assert D({"zero": T}) == {"real": T, "zero": T}
assert D({"pos": T}) == {"real": T, "pos": T}
# --- key tests below ---
assert D({
"neg": F,
"zero": F,
"pos": F
}) == {
"real": F,
"neg": F,
"zero": F,
"pos": F,
}
assert D({"real": T, "neg": F}) == {"real": T, "neg": F}
assert D({"real": T, "zero": F}) == {"real": T, "zero": F}
assert D({"real": T, "pos": F}) == {"real": T, "pos": F}
assert D({
"real": T,
"zero": F,
"pos": F
}) == {
"real": T,
"neg": T,
"zero": F,
"pos": F,
}
assert D({
"real": T,
"neg": F,
"pos": F
}) == {
"real": T,
"neg": F,
"zero": T,
"pos": F,
}
assert D({
"real": T,
"neg": F,
"zero": F
}) == {
"real": T,
"neg": F,
"zero": F,
"pos": T,
}
assert D({
"neg": T,
"zero": F,
"pos": F
}) == {
"real": T,
"neg": T,
"zero": F,
"pos": F,
}
assert D({
"neg": F,
"zero": T,
"pos": F
}) == {
"real": T,
"neg": F,
"zero": T,
"pos": F,
}
assert D({
"neg": F,
"zero": F,
"pos": T
}) == {
"real": T,
"neg": F,
"zero": F,
"pos": T,
}
