Python pl_true示例

示例#1

def dpll(clauses, symbols, model):
    """
    Compute satisfiability in a partial model.
    Clauses is an array of conjuncts.

    >>> from diofant.abc import A, B, D
    >>> from diofant.logic.algorithms.dpll import dpll
    >>> dpll([A, B, D], [A, B], {D: False})
    False

    """
    # compute DP kernel
    P, value = find_unit_clause(clauses, model)
    while P:
        model.update({P: value})
        symbols.remove(P)
        if not value:
            P = ~P
        clauses = unit_propagate(clauses, P)
        P, value = find_unit_clause(clauses, model)
    P, value = find_pure_symbol(symbols, clauses)
    while P:
        model.update({P: value})
        symbols.remove(P)
        if not value:
            P = ~P
        clauses = unit_propagate(clauses, P)
        P, value = find_pure_symbol(symbols, clauses)
    # end DP kernel
    unknown_clauses = []
    for c in clauses:
        val = pl_true(c, model)
        if val is False:
            return False
        if val is not True:
            unknown_clauses.append(c)
    if not unknown_clauses:
        return model
    if not clauses:
        return model
    P = symbols.pop()
    model_copy = model.copy()
    model.update({P: True})
    model_copy.update({P: False})
    symbols_copy = symbols[:]
    return (dpll(unit_propagate(unknown_clauses, P), symbols, model) or
            dpll(unit_propagate(unknown_clauses, Not(P)), symbols_copy, model_copy))

示例#2

文件： test_inference.py 项目： Blendify/diofant

def test_pl_true_wrong_input():
    pytest.raises(ValueError, lambda: pl_true('John Cleese'))
    pytest.raises(ValueError, lambda: pl_true(42 + pi + pi ** 2))
    pytest.raises(ValueError, lambda: pl_true(42))

示例#3

文件： test_inference.py 项目： Blendify/diofant

def test_pl_true():
    assert pl_true(True) is True
    assert pl_true( A & B, {A: True, B: True}) is True
    assert pl_true( A | B, {A: True}) is True
    assert pl_true( A | B, {B: True}) is True
    assert pl_true( A | B, {A: None, B: True}) is True
    assert pl_true( A >> B, {A: False}) is True
    assert pl_true( A | B | ~C, {A: False, B: True, C: True}) is True
    assert pl_true(Equivalent(A, B), {A: False, B: False}) is True

    # test for false
    assert pl_true(False) is False
    assert pl_true( A & B, {A: False, B: False}) is False
    assert pl_true( A & B, {A: False}) is False
    assert pl_true( A & B, {B: False}) is False
    assert pl_true( A | B, {A: False, B: False}) is False

    # test for None
    assert pl_true(B, {B: None}) is None
    assert pl_true( A & B, {A: True, B: None}) is None
    assert pl_true( A >> B, {A: True, B: None}) is None
    assert pl_true(Equivalent(A, B), {A: None}) is None
    assert pl_true(Equivalent(A, B), {A: True, B: None}) is None

    # Test for deep
    assert pl_true(A | B, {A: False}, deep=True) is None
    assert pl_true(~A & ~B, {A: False}, deep=True) is None
    assert pl_true(A | B, {A: False, B: False}, deep=True) is False
    assert pl_true(A & B & (~A | ~B), {A: True}, deep=True) is False
    assert pl_true((C >> A) >> (B >> A), {C: True}, deep=True) is True

示例#4

文件： test_inference.py 项目： goretkin/diofant

def test_pl_true_wrong_input():
    from diofant import pi
    pytest.raises(ValueError, lambda: pl_true('John Cleese'))
    pytest.raises(ValueError, lambda: pl_true(42 + pi + pi ** 2))
    pytest.raises(ValueError, lambda: pl_true(42))

示例#5

文件： test_inference.py 项目： skirpichev/diofant

def test_pl_true_wrong_input():
    pytest.raises(ValueError, lambda: pl_true('John Cleese'))
    pytest.raises(ValueError, lambda: pl_true(42 + pi + pi ** 2))
    pytest.raises(ValueError, lambda: pl_true(42))

示例#6

文件： test_inference.py 项目： skirpichev/diofant

def test_pl_true():
    assert pl_true(True) is True
    assert pl_true( A & B, {A: True, B: True}) is True
    assert pl_true( A | B, {A: True}) is True
    assert pl_true( A | B, {B: True}) is True
    assert pl_true( A | B, {A: None, B: True}) is True
    assert pl_true( A >> B, {A: False}) is True
    assert pl_true( A | B | ~C, {A: False, B: True, C: True}) is True
    assert pl_true(Equivalent(A, B), {A: False, B: False}) is True

    # test for false
    assert pl_true(False) is False
    assert pl_true( A & B, {A: False, B: False}) is False
    assert pl_true( A & B, {A: False}) is False
    assert pl_true( A & B, {B: False}) is False
    assert pl_true( A | B, {A: False, B: False}) is False

    # test for None
    assert pl_true(B, {B: None}) is None
    assert pl_true( A & B, {A: True, B: None}) is None
    assert pl_true( A >> B, {A: True, B: None}) is None
    assert pl_true(Equivalent(A, B), {A: None}) is None
    assert pl_true(Equivalent(A, B), {A: True, B: None}) is None

    # Test for deep
    assert pl_true(A | B, {A: False}, deep=True) is None
    assert pl_true(~A & ~B, {A: False}, deep=True) is None
    assert pl_true(A | B, {A: False, B: False}, deep=True) is False
    assert pl_true(A & B & (~A | ~B), {A: True}, deep=True) is False
    assert pl_true((C >> A) >> (B >> A), {C: True}, deep=True) is True

示例#7

文件： test_inference.py 项目： diofant/diofant

def test_pl_true():
    assert pl_true(True) is True
    assert pl_true(a & b, {a: True, b: True}) is True
    assert pl_true(a | b, {a: True}) is True
    assert pl_true(a | b, {b: True}) is True
    assert pl_true(a | b, {a: None, b: True}) is True
    assert pl_true(a >> b, {a: False}) is True
    assert pl_true(a | b | ~c, {a: False, b: True, c: True}) is True
    assert pl_true(Equivalent(a, b), {a: False, b: False}) is True

    assert pl_true(False) is False
    assert pl_true(a & b, {a: False, b: False}) is False
    assert pl_true(a & b, {a: False}) is False
    assert pl_true(a & b, {b: False}) is False
    assert pl_true(a | b, {a: False, b: False}) is False

    assert pl_true(b, {b: None}) is None
    assert pl_true(a & b, {a: True, b: None}) is None
    assert pl_true(a >> b, {a: True, b: None}) is None
    assert pl_true(Equivalent(a, b), {a: None}) is None
    assert pl_true(Equivalent(a, b), {a: True, b: None}) is None

    assert pl_true(a | b, {a: False}, deep=True) is None
    assert pl_true(~a & ~b, {a: False}, deep=True) is None
    assert pl_true(a | b, {a: False, b: False}, deep=True) is False
    assert pl_true(a & b & (~a | ~b), {a: True}, deep=True) is False
    assert pl_true((c >> a) >> (b >> a), {c: True}, deep=True) is True

    pytest.raises(ValueError, lambda: pl_true('John Cleese'))
    pytest.raises(ValueError, lambda: pl_true(42 + pi))
    pytest.raises(ValueError, lambda: pl_true(42))