Esempio n. 1
0
def T5(F, G):
    """
        (F->G) -> (!G -> !F)
    """

    if type(F) is Node:
        nf = Node(F.left, F.right, _not=not F._not)
    else:
        nf = Variable(F.symbol, _not=not F._not)

    if type(G) is Node:
        ng = Node(G.left, G.right, _not=not G._not)
    else:
        ng = Variable(G.symbol, _not=not G._not)

    f1 = Node(F, G)
    f2 = Node(ng, nf)

    msg = "T5 for " + str(F) + ", " + str(G)

    return Node(f1, f2, msg=msg)
Esempio n. 2
0
def T3(F, G):
    """
        !F -> (F->G)
    """

    if type(F) is Node:
        nf = Node(F.left, F.right, _not=not F._not)
    else:
        nf = Variable(F.symbol, _not=not F._not)

    fg = Node(F, G)

    msg = "T3 for " + str(F) + ", " + str(G)

    return Node(nf, fg, msg=msg)
Esempio n. 3
0
def T6(F, G):
    """
        F -> (!G -> !(F->G) )
    """

    if type(G) is Node:
        ng = Node(G.left, G.right, _not=not G._not)
    else:
        ng = Variable(G.symbol, _not=not G._not)

    nFG = Node(F, G, _not=True)

    f2 = Node(ng, nFG)

    msg = "T6 for " + str(F) + ", " + str(G)

    return Node(F, f2, msg=msg)
Esempio n. 4
0
def T7(F, G):
    """
        (F->G) -> ( (!F->G) ->G )
    """

    if type(F) is Node:
        nf = Node(F.left, F.right, _not=not F._not)
    else:
        nf = Variable(F.symbol, _not=not F._not)

    fg = Node(F, G)

    nf_g = Node(nf, G)
    nfg_G = Node(nf_g, G)  # (!F->G)->G

    msg = "T7 for " + str(F) + ", " + str(G)

    return Node(fg, nfg_G, msg=msg)
Esempio n. 5
0
 def variable(self, name):
     from formula import Variable
     logger.debug(f"Parsing variable term with name {str(name)}")
     return Variable(self.system, str(name))
Esempio n. 6
0
File: cv03.py Progetto: stiffix/udvl
        for interpretation, result in cases:
            print(" interpretation %s:" % (repr(interpretation), ))
            self.compare(formula.eval(interpretation), result, "eval")

    def status(self):
        print("TESTED %d" % (self.tested, ))
        print("PASSED %d" % (self.passed, ))
        if self.tested == self.passed:
            print("OK")
        else:
            print("ERROR")


t = Tester()

t.test(Variable('a'), 'a', [
    ({
        'a': True
    }, True),
    ({
        'a': False
    }, False),
])

t.test(Negation(Variable('a')), '-a', [
    ({
        'a': True
    }, False),
    ({
        'a': False
    }, True),
Esempio n. 7
0
    def testTableau(self, expect_closed, sfs):
        self.case += 1
        self.tested += 1
        strSfs = [sf.toString() for sf in sfs]
        print("CASE %d: %s" % (self.case, '; '.join(strSfs)))
        tableau = Node(False, Variable(""))
        try:
            start = now()
            tableau = TableauBuilder().build(sfs)
            duration = now() - start
        except KeyboardInterrupt:
            raise KeyboardInterrupt()
        except:
            printException()
            if stopOnError:
                raise FailedTestException()
            return

        if not isinstance(tableau, Tableau):
            print('FAILED: not a tableau.Tableau: %s' % type(tableau))
            print()
            return

        if not isinstance(tableau.root, Node):
            print('FAILED: not a tableau.Node: %s' % type(tableau))
            print()
            return

        closed = tableau.isClosed()
        badStructure = False
        try:
            self.testTableauStructure(tableau.root, [], strSfs)
        except BadTableauException as err:
            badStructure = str(err)
        except:
            printException()
            if stopOnError:
                raise FailedTestException()
            return

        size = tableau.size()

        self.time += duration
        self.size += size

        if closed:
            self.closed += 1

        passed = closed == expect_closed and not badStructure
        if passed:
            self.passed += 1
            print('PASSED:  time: %12.9f   tableau size: %3d   %s' %
                  (duration, size, self.closedToString(closed)))
        else:
            print('FAILED: ')

        if not passed or showAll:
            print('=====TABLEAU=====\n%s\n%s' % (tableau.toString(), '=' * 13))

        if not passed:
            if closed != expect_closed:
                print('Tableau is %s, but should be %s' %
                      (self.closedToString(closed),
                       self.closedToString(expect_closed)))
            if badStructure:
                print(badStructure)
            if stopOnError:
                raise FailedTestException()
        print('')
Esempio n. 8
0
}, {
    'a': True,
    'b': False,
    'c': True
}, {
    'a': False,
    'b': True,
    'c': True
}, {
    'a': True,
    'b': True,
    'c': True
}]

testFormulas = [
    (Variable('a'), 'a', 0, ['a'], [
        ({
            'a': True
        }, True),
        ({
            'a': False
        }, False),
    ]),
    (Negation(Variable('a')), '-a', 1, ['a'], [
        ({
            'a': True
        }, False),
        ({
            'a': False
        }, True),
    ]),
Esempio n. 9
0
def Ad_Theorem(F):
    '''

        Adequacy theorem implementation

    :param F: Propositional calculus formula: Variable or Node
    :return: formal proof |- F
    '''

    global proof

    symbols = list(F.used_symbols())
    symbolsCount = len(symbols)

    N = 1 << symbolsCount

    vector = 0  # why not int for vector?
    n = 0

    while n < len(symbols):
        vector = 0
        while vector < N:
            X_n = symbols[n]
            values = {
                symbols[k]: 0 if vector & (1 << k) == 0 else 1
                for k in range(len(symbols))
            }
            values_not = values.copy()

            values[X_n] = 1
            values[X_n] = 0

            C1 = Calmar_Theorem(F, values)
            C2 = Calmar_Theorem(F, values_not)

            hypo = [
                Variable(k, _not=True if v == 0 else False)
                for k, v in values.items()
            ]
            deductC1 = build_deduction(hypo, Variable(X_n), F, C1)

            hypo = [
                Variable(k, _not=True if v == 0 else False)
                for k, v in values.items()
            ]
            deductC2 = build_deduction(hypo, Variable(X_n, _not=True), F, C2)

            if len(C1) == 0 or len(C2) == 0:
                vector += 1
                continue

            ld1 = deductC1[-1]
            ld2 = deductC2[-1]

            t7 = build_T7(Variable(X_n), F)
            T7 = t7[-1]
            mp1 = MP(ld1, T7)
            mp2 = MP(ld2, mp1)

            proof.extend(deductC1)
            proof.extend(deductC2)
            proof.extend(t7)
            proof.extend([mp1, mp2])

            curLen = len(proof)  #for debug

            vector += 1

        n += 1

    return proof
Esempio n. 10
0
def Calmar_Theorem(F, values):
    '''
        Calmar's Theorem implementation

    :param F: Propositional calculus formula: Variable or Node
    :return:
    '''

    if type(F) == Variable:
        v = Variable(F.symbol, _not=True if values[F.symbol] == 1 else 0)

        return [v]

    if F._not:  # F = !G
        G = Node(None, None)
        G.left = F.left  # Copy G, but F = !G
        G.right = F.right

        if F.calculate(values) == 1:
            G.msg = "Calmar's theorem, 1.a) F^(alpha) = G^(alpha) => hypoth |- G^() = F^()"

            return [G]

        else:
            # !f = !!g
            t2 = build_T2(G)
            T2 = t2[-1]

            nng = MP(G, T2)

            res = t2
            res.append(nng)
            return res

    else:  # F = G->H

        res = []

        G = F.left
        H = F.right

        if G.calculate(values) == 0:

            nG = notFormula(G)
            t3 = build_T3(G, H)

            T = t3[-1]
            mp = MP(nG, T)

            res = t3
            res.append(mp)

        elif H.calculate(values) == 1:

            # h->(g->h)
            h = H
            hgh = axiom.A1(H, G)

            gh = MP(h, hgh)

            return [hgh, gh]

        else:
            # F = !(G->H)
            # have G, !H. proof !(G->H)

            nH = notFormula(H)

            t6 = build_T6(G, H)
            T6 = t6[-1]

            f1 = MP(G, T6)
            f2 = MP(nH, f1)

            res = t6
            res.extend([f1, f2])

        return res
Esempio n. 11
0
            proof.extend(deductC2)
            proof.extend(t7)
            proof.extend([mp1, mp2])

            curLen = len(proof)  #for debug

            vector += 1

        n += 1

    return proof


if __name__ == '__main__':

    f = Variable('F')
    g = Variable('G')

    nf = notFormula(f)
    nnf = notFormula(nf)
    Ad_Theorem(Node(nnf, f))

    t4 = build_T4(f, g)
    T4 = t4[-1]
    t5 = build_T5(f, g)
    t6 = build_T6(f, g)
    t7 = build_T7(f, g)
    T7 = t7[-1]

    print('no exception? it is small victory')
Esempio n. 12
0
            print(" interpretation %s:" % (repr(interpretation),))
            self.compare(parsed.eval(interpretation), result, "eval")


    def status(self):
        print("TESTED %d" % (self.tested,))
        print("PASSED %d" % (self.passed,))
        if self.tested == self.passed:
            print("OK")
        else:
            print("ERROR")

t = Tester()

t.test(
        Variable('a'), 'a',
        [
            ({'a':True}, True),
            ({'a':False}, False),
        ])

t.test(
        Negation(Variable('a')), '-a',
        [
            ({'a':True}, False),
            ({'a':False}, True),
        ])


interps2 = [{ 'a': False, 'b': False },
            { 'a': False, 'b': True  },
Esempio n. 13
0
        pass

    return False


def if_Axiom(F):
    """
        Check if F is Axiom
    """

    return if_A1(F) or if_A2(F) or if_A3(F)


if __name__ == '__main__':

    f1 = Variable('F')
    f2 = Node(Variable('F'), Variable('G'))
    print(MP(f1, f2))
    exit()

    f1 = "(A->B)"
    f2 = "(A->!(B->!C))"
    tests = [
        "F->(G->F)", "G->(F->G)", "F->(F->F)", "!F->((A->B)->!F)",
        "(A->(B->C))->((A->B)->(A->C))",
        "({0}->(B->{1}))->(({0}->B)->({0}->{1}))".format(f1, f2),
        "(!G->!F)->((!G->F)->G)", "(!G->!G)->((!G->G)->G)",
        "(!(f1)->!(f2))->((!(f1)->(f2))->(f1))".replace('f1',
                                                        f1).replace('f2', f2)
    ]