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, }