Python Clause示例

示例#1

def test_at_most_one_multiple_literals():
    amo = Clause(ClauseType.AT_MOST_ONE,
                 [Literal("1"),
                  Literal("2", assignment=True),
                  Literal("3")])
    assert check_clause_consistency(amo) is None

    amo = Clause(ClauseType.AT_MOST_ONE, [
        Literal("1", assignment=False),
        Literal("2", assignment=False),
        Literal("3", assignment=False)
    ])
    assert check_clause_consistency(amo)

    amo = Clause(ClauseType.AT_MOST_ONE, [
        Literal("1", assignment=False),
        Literal("2", assignment=False),
        Literal("3", assignment=True)
    ])
    assert check_clause_consistency(amo)

    amo = Clause(ClauseType.AT_MOST_ONE, [
        Literal("1", assignment=False),
        Literal("2", assignment=True),
        Literal("3", assignment=True)
    ])
    assert check_clause_consistency(amo) == False

    amo = Clause(ClauseType.AT_MOST_ONE, [
        Literal("1", assignment=True),
        Literal("2", assignment=True),
        Literal("3", assignment=True)
    ])
    assert check_clause_consistency(amo) == False

示例#2

文件： test_dpll.py 项目： hipaapotamus/hipaasat

def test_single_literal_multiple_clauses_unsolvable():
    solver = DPLL()
    cnf = CNF([
        Clause(ClauseType.OR, [
            Literal("test")
        ]),
        Clause(ClauseType.OR, [
            Literal("test", negated=True)
        ]),
        Clause(ClauseType.OR, [
            Literal("test")
        ]),
    ])
    solved, _ = solver.solve(cnf)
    assert not solved

示例#3

文件： test_dpll.py 项目： hipaapotamus/hipaasat

def test_single_literal_multiple_clauses():
    solver = DPLL()
    cnf = CNF([
        Clause(ClauseType.OR, [
            Literal("test")
        ]),
        Clause(ClauseType.OR, [
            Literal("test")
        ]),
        Clause(ClauseType.OR, [
            Literal("test")
        ]),
    ])
    solved, result_cnf = solver.solve(cnf)
    assert solved
    assert result_cnf.assigned_literal_count() == result_cnf.unique_literal_count()

示例#4

def test_or_clause_consistency_single_literal():
    oc = Clause(ClauseType.OR, [Literal("test")])
    assert check_clause_consistency(oc) is None

    oc = Clause(ClauseType.OR, [Literal("test", assignment=True)])
    assert check_clause_consistency(oc)

    oc = Clause(ClauseType.OR, [Literal("test", assignment=False)])
    assert check_clause_consistency(oc) == False

    oc = Clause(ClauseType.OR,
                [Literal("test", negated=True, assignment=False)])
    assert check_clause_consistency(oc)

    oc = Clause(ClauseType.OR,
                [Literal("test", negated=True, assignment=True)])
    assert check_clause_consistency(oc) == False

示例#5

文件： test_dpll.py 项目： hipaapotamus/hipaasat

def test_multiple_literals_multiple_clauses_2():
    solver = DPLL()
    cnf = CNF([
        Clause(ClauseType.OR, [
            Literal("lib-1"), Literal("lib-2"), Literal("prog-1", negated=True),
        ]),
        Clause(ClauseType.OR, [
            Literal("lib-2"), Literal("prog-2", negated=True),
        ]),
        Clause(ClauseType.OR, [
            Literal("python-2"), Literal("lib-1", negated=True),
        ]),
        Clause(ClauseType.OR, [
            Literal("python-3"), Literal("lib-2", negated=True),
        ]),
        Clause(ClauseType.OR, [
            Literal("python-3", negated=True)
        ]),
        Clause(ClauseType.OR, [
            Literal("prog-1"), Literal("prog-2"),
        ]),
        Clause(ClauseType.AT_MOST_ONE, [
            Literal("prog-1"), Literal("prog-2"),
        ]),
        Clause(ClauseType.AT_MOST_ONE, [
            Literal("lib-1"), Literal("lib-2"),
        ]),
        Clause(ClauseType.AT_MOST_ONE, [
            Literal("python-2"), Literal("python-3"),
        ]),
    ])

    solved, result_cnf = solver.solve(cnf)
    assert solved
    assert result_cnf.assigned_literal_count() == result_cnf.unique_literal_count()

    prog1 = result_cnf.get_literal("prog-1")
    prog2 = result_cnf.get_literal("prog-2")
    lib1 = result_cnf.get_literal("lib-1")
    lib2 = result_cnf.get_literal("lib-2")
    python2 = result_cnf.get_literal("python-2")
    python3 = result_cnf.get_literal("python-3")

    assert prog1 and prog1.assignment == True
    assert prog2 and prog2.assignment == False
    assert lib1 and lib1.assignment == True
    assert lib2 and lib2.assignment == False
    assert python2 and python2.assignment == True
    assert python3 and python3.assignment == False

示例#6

文件： test_dpll.py 项目： hipaapotamus/hipaasat

def test_multiple_literals_single_clause():
    solver = DPLL()
    cnf = CNF([
        Clause(ClauseType.OR, [
            Literal("test"), Literal("test2", negated=True), Literal("test3")
        ]),
    ])
    solved, result_cnf = solver.solve(cnf)
    assert solved
    assert result_cnf.assigned_literal_count() == 1

示例#7

def test_cnf_single_clause():
    oc = Clause(ClauseType.OR, [Literal("1"), Literal("2")])
    cnf = CNF([oc])
    assert check_consistency(cnf) is None

    oc = Clause(ClauseType.OR, [Literal("test", assignment=True)])
    cnf = CNF([oc])
    assert check_consistency(cnf)

    oc = Clause(ClauseType.OR, [Literal("test", assignment=False)])
    cnf = CNF([oc])
    assert check_consistency(cnf) == False

    oc = Clause(ClauseType.OR,
                [Literal("test", negated=True, assignment=False)])
    cnf = CNF([oc])
    assert check_consistency(cnf)

    oc = Clause(ClauseType.OR,
                [Literal("test", negated=True, assignment=True)])
    cnf = CNF([oc])
    assert check_consistency(cnf) == False

示例#8

文件： test_dpll.py 项目： hipaapotamus/hipaasat

def test_multiple_literals_multiple_clauses_1():
    solver = DPLL()
    cnf = CNF([
        Clause(ClauseType.OR, [
            Literal("a", negated=True), Literal("b"), Literal("c"),
        ]),
        Clause(ClauseType.OR, [
            Literal("a"), Literal("c"), Literal("d"),
        ]),
        Clause(ClauseType.OR, [
            Literal("a"), Literal("c"), Literal("d", negated=True),
        ]),
        Clause(ClauseType.OR, [
            Literal("a"), Literal("c", negated=True), Literal("d"),
        ]),
        Clause(ClauseType.OR, [
            Literal("a"), Literal("c", negated=True), Literal("d", negated=True),
        ]),
        Clause(ClauseType.OR, [
            Literal("b", negated=True), Literal("c", negated=True), Literal("d"),
        ]),
        Clause(ClauseType.OR, [
            Literal("a", negated=True), Literal("b"), Literal("c", negated=True),
        ]),
        Clause(ClauseType.OR, [
            Literal("a", negated=True), Literal("b", negated=True), Literal("c")
        ]),
    ])
    solved, result_cnf = solver.solve(cnf)
    assert solved
    assert result_cnf.assigned_literal_count() == result_cnf.unique_literal_count()
    
    a = result_cnf.get_literal("a")
    b = result_cnf.get_literal("b")
    c = result_cnf.get_literal("c")
    d = result_cnf.get_literal("d")

    assert a and a.assignment == True
    assert b and b.assignment == True
    assert c and c.assignment == True
    assert d and d.assignment == True

示例#9

def test_or_clause_consistency_multiple_literals():
    oc = Clause(ClauseType.OR, [Literal("1"), Literal("2")])
    assert check_clause_consistency(oc) is None

    oc = Clause(ClauseType.OR, [Literal("1", assignment=True), Literal("2")])
    assert check_clause_consistency(oc)

    oc = Clause(
        ClauseType.OR,
        [Literal("1", assignment=False),
         Literal("2", assignment=True)])
    assert check_clause_consistency(oc)

    oc = Clause(ClauseType.OR, [
        Literal("1", negated=True, assignment=False),
        Literal("2", assignment=True)
    ])
    assert check_clause_consistency(oc)

    oc = Clause(ClauseType.OR, [
        Literal("1", negated=True, assignment=False),
        Literal("2", assignment=False),
        Literal("3", assignment=False)
    ])
    assert check_clause_consistency(oc)

    oc = Clause(ClauseType.OR, [
        Literal("1", assignment=False),
        Literal("2", assignment=False),
        Literal("3", assignment=False)
    ])
    assert check_clause_consistency(oc) == False

    lits = [Literal(str(i), assignment=False) for i in range(100)]
    lits.append(Literal(name="100", negated=True, assignment=False))
    oc = Clause(ClauseType.OR, lits)
    assert check_clause_consistency(oc)

示例#10

def test_cnf_multiple_clauses():
    cnf = CNF([
        Clause(ClauseType.OR, [Literal("1"), Literal("2")]),
        Clause(ClauseType.OR,
               [Literal("2", assignment=True),
                Literal("3", assignment=True)]),
        Clause(ClauseType.OR,
               [Literal("4", assignment=True),
                Literal("5", assignment=True)])
    ])
    assert check_consistency(cnf) is None

    cnf = CNF([
        Clause(ClauseType.OR,
               [Literal("1", assignment=True),
                Literal("2", assignment=True)]),
        Clause(ClauseType.OR,
               [Literal("2", assignment=True),
                Literal("3", assignment=True)]),
        Clause(ClauseType.OR,
               [Literal("4", assignment=True),
                Literal("5", assignment=True)])
    ])
    assert check_consistency(cnf)

    cnf = CNF([
        Clause(
            ClauseType.OR,
            [Literal("1", assignment=False),
             Literal("2", assignment=False)]),
        Clause(ClauseType.OR,
               [Literal("2", assignment=False),
                Literal("3", assignment=True)]),
        Clause(ClauseType.OR,
               [Literal("4", assignment=True),
                Literal("5", assignment=True)])
    ])
    assert check_consistency(cnf) == False

    cnf = CNF([
        Clause(ClauseType.OR,
               [Literal("1"), Literal("2", assignment=True)]),
        Clause(
            ClauseType.OR,
            [Literal("2", assignment=False),
             Literal("3", assignment=False)]),
        Clause(ClauseType.OR,
               [Literal("4", assignment=True),
                Literal("5", assignment=True)])
    ])
    assert check_consistency(cnf) == False