raj_mathe
/
logik2021
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

master > master: Teile auslagern + Vereinfachungen

This commit is contained in:
RD 2021-05-06 15:29:44 +02:00
parent d94d508e8c
commit 6f6de00296
4 changed files with 153 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
code/aussagenlogik/rekursion.py
View File

@ -9,6 +9,17 @@ from __future__ import annotations;
from lark import Tree;
from typing import List;
from aussagenlogik.schema import isAtom;
from aussagenlogik.schema import isBeliebig;
from aussagenlogik.schema import isTrueSymbol;
from aussagenlogik.schema import isFalseSymbol;
from aussagenlogik.schema import isNegation;
from aussagenlogik.schema import isConjunction;
from aussagenlogik.schema import isDisjunction;
from aussagenlogik.schema import isImplication;
from aussagenlogik.schema import getTeilformeln;
from aussagenlogik.schema import getName;
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# GLOBALE KONSTANTEN
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -19,6 +30,35 @@ from typing import List;
# METHODEN
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def rekursiv_eval(fml: Tree, I: List[str]) -> int:
teilfml = getTeilformeln(fml);
if isAtom(fml):
name = getName(fml);
return 1 if (name in I) else 0;
if isBeliebig(fml):
name = getName(fml);
return 1 if (name in I) else 0;
elif isTrueSymbol(fml):
return 1;
elif isFalseSymbol(fml):
return 0;
elif isNegation(fml):
val0 = rekursiv_eval(teilfml[0], I);
return 1 - val0;
elif isConjunction(fml):
val0 = rekursiv_eval(teilfml[0], I);
val1 = rekursiv_eval(teilfml[1], I);
return min(val0, val1);
elif isDisjunction(fml):
val0 = rekursiv_eval(teilfml[0], I);
val1 = rekursiv_eval(teilfml[1], I);
return max(val0, val1);
elif isImplication(fml):
val0 = rekursiv_eval(teilfml[0], I);
val1 = rekursiv_eval(teilfml[1], I);
return 0 if val0 == 1 and val1 == 0 else 1;
raise Exception('Evaluation nicht möglich!');
def rekursiv_atoms(fml: Tree) -> List[str]:
## Herausforderung: schreibe diese Funktion!
return [];
@ -34,46 +74,3 @@ def rekursiv_length(fml: Tree) -> int:
def rekursiv_parentheses(fml: Tree) -> int:
## Herausforderung: schreibe diese Funktion!
return 0
def rekursiv_eval(fml: Tree, I: List[str]) -> int:
teilfml = getTeilformeln(fml);
if fml.data in ['atom', 'beliebig']:
name = getText(fml);
return 1 if (name in I) else 0;
elif fml.data == 'wahr':
return 1;
elif fml.data == 'falsch':
return 0;
elif fml.data == 'negation':
val1 = rekursiv_eval(teilfml[0], I);
return 1 - val1;
elif fml.data == 'konjunktion':
val1 = rekursiv_eval(teilfml[0], I);
val2 = rekursiv_eval(teilfml[1], I);
return min(val1, val2);
elif fml.data == 'disjunktion':
val1 = rekursiv_eval(teilfml[0], I);
val2 = rekursiv_eval(teilfml[1], I);
return max(val1, val2);
elif fml.data == 'implikation':
val1 = rekursiv_eval(teilfml[0], I);
val2 = rekursiv_eval(teilfml[1], I);
return 0 if val1 == 1 and val2 == 0 else 1;
raise Exception('Evaluation nicht möglich!');
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# HILFSMETHODEN
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def getText(fml: Tree) -> str:
text = fml.children[0];
if isinstance(text, str):
return text;
raise Exception('Konnte Textinhalt nicht ablesen!');
def getTeilformeln(fml: Tree) -> List[Tree]:
return [
part for part in fml.children
if isinstance(part, Tree)
and not part.data == 'junktor'
];

55
code/aussagenlogik/schema.py
View File

@ -6,11 +6,11 @@
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
from __future__ import annotations;
import re;
# install: lark; lark-parser; lark-parser[regex].
# https://lark-parser.readthedocs.io/en/latest/grammar.html
from lark import Lark;
from lark import Tree;
from typing import List;
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# GLOBALE KONSTANTEN
@ -53,12 +53,61 @@ lexerAussagenlogik = Lark(
);
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# MAIN METHOD string -> parts
# METHODE: string -> Syntaxbaum
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def string_to_parts(u: str) -> Tree:
def stringToSyntaxbaum(u: str) -> Tree:
try:
u_lexed = lexerAussagenlogik.parse(u);
return u_lexed;
except:
raise Exception('Ausdruck \033[1m{}\033[0m konnte nicht erkannt werden!'.format(u));
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# METHODEN: Erkennung von Formeltypen
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def isAtom(fml: Tree) -> bool:
return fml.data == 'atom';
def isBeliebig(fml: Tree) -> bool:
return fml.data == 'beliebig';
def isTrueSymbol(fml: Tree) -> bool:
return fml.data == 'wahr';
def isFalseSymbol(fml: Tree) -> bool:
return fml.data == 'falsch';
def isNegation(fml: Tree) -> bool:
return fml.data == 'negation';
def isConjunction(fml: Tree) -> bool:
return fml.data == 'konjunktion';
def isDisjunction(fml: Tree) -> bool:
return fml.data == 'disjunktion';
def isImplication(fml: Tree) -> bool:
return fml.data == 'implikation';
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# METHODEN: Formel -> Teilformeln
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def getTeilformeln(fml: Tree) -> List[Tree]:
return [
part for part in fml.children
if isinstance(part, Tree)
and not part.data == 'junktor'
];
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# METHODEN: Formel (Atom/Beliebig) -> Name
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def getName(fml: Tree) -> str:
text = fml.children[0];
if isinstance(text, str):
return text;
raise Exception('Konnte Textinhalt nicht ablesen!');

4
code/main.py
View File

@ -16,7 +16,7 @@ from typing import List;
sys.path.insert(0, os.getcwd());
from aussagenlogik.schema import string_to_parts;
from aussagenlogik.schema import stringToSyntaxbaum;
from aussagenlogik.rekursion import rekursiv_eval;
from aussagenlogik.rekursion import rekursiv_atoms;
from aussagenlogik.rekursion import rekursiv_depth;
@ -37,7 +37,7 @@ def main():
## Daten einlesen:
expr, I = getData();
## Formel in Teilformeln zerlegen:
tree = string_to_parts(expr);
tree = stringToSyntaxbaum(expr);
## Methoden ausführen:
results = dict(
eval = rekursiv_eval(tree, I),

120
code/utests/u_rekursion.py
View File

@ -8,7 +8,7 @@
import unittest;
from unittest import TestCase;
from aussagenlogik.schema import string_to_parts;
from aussagenlogik.schema import stringToSyntaxbaum;
from aussagenlogik.rekursion import rekursiv_atoms;
from aussagenlogik.rekursion import rekursiv_depth;
from aussagenlogik.rekursion import rekursiv_length;
@ -21,6 +21,45 @@ from aussagenlogik.rekursion import rekursiv_eval;
#
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# TESTFALL eval(·, ·)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# @unittest.skip('Methode noch nicht implementiert')
class TestRekursivEval(TestCase):
def test_literale(self):
fml = stringToSyntaxbaum('A0');
val = rekursiv_eval(fml, [ 'A0' ]);
assert val == 1;
fml = stringToSyntaxbaum('A0');
val = rekursiv_eval(fml, []);
assert val == 0;
fml = stringToSyntaxbaum('! A0');
val = rekursiv_eval(fml, [ 'A0' ]);
assert val == 0;
fml = stringToSyntaxbaum('! A0');
val = rekursiv_eval(fml, []);
assert val == 1;
def test_complex1(self):
fml = stringToSyntaxbaum('( ! A0 || (( A0 && A3 ) || A2 ))');
val = rekursiv_eval(fml, [ 'A0', 'A2' ]);
assert val == 1;
val = rekursiv_eval(fml, [ 'A0', 'A3' ]);
assert val == 1;
val = rekursiv_eval(fml, [ 'A0' ]);
assert val == 0;
val = rekursiv_eval(fml, [ 'A4', 'A8' ]);
assert val == 1;
def test_complex2(self):
fml = stringToSyntaxbaum('( ! A0 || (( A0 && A3 ) || ! A2 ))');
val = rekursiv_eval(fml, [ 'A0', 'A2' ]);
assert val == 0;
val = rekursiv_eval(fml, [ 'A0', 'A3' ]);
assert val == 1;
pass;
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# TESTFALL Atome(·)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -28,22 +67,22 @@ from aussagenlogik.rekursion import rekursiv_eval;
@unittest.skip('Methode noch nicht implementiert')
class TestRekursivAtoms(TestCase):
def test_noduplicates(self):
fml = string_to_parts('( A4 && ( A4 || A4 ))');
fml = stringToSyntaxbaum('( A4 && ( A4 || A4 ))');
val = sorted(rekursiv_atoms(fml));
assert len([_ for _ in val if _ == 'A4']) == 1, 'Atome dürfen nicht mehrfach vorkommen!';
def test_nononatoms(self):
fml = string_to_parts('( {F} || A3 )');
fml = stringToSyntaxbaum('( {F} || A3 )');
val = sorted(rekursiv_atoms(fml));
assert 'F' not in val, 'Nichtatomare Formeln dürfen nicht vorkommen!';
def test_calc1(self):
fml = string_to_parts('A0');
fml = stringToSyntaxbaum('A0');
val = sorted(rekursiv_atoms(fml));
assert val == ['A0'], 'computed {}'.format(val);
def test_calc2(self):
fml = string_to_parts('((( ! A0 && A3 ) || A4 ) && A8 )');
fml = stringToSyntaxbaum('((( ! A0 && A3 ) || A4 ) && A8 )');
val = sorted(rekursiv_atoms(fml));
assert val == ['A0', 'A3', 'A4', 'A8'], 'computed {}'.format(val);
pass;
@ -55,27 +94,27 @@ class TestRekursivAtoms(TestCase):
@unittest.skip('Methode noch nicht implementiert')
class TestRekursivDepth(TestCase):
def test_calc1(self):
fml = string_to_parts('A0');
fml = stringToSyntaxbaum('A0');
val = rekursiv_depth(fml);
assert val == 0, 'computed {}'.format(val);
def test_calc2(self):
fml = string_to_parts('!! A8');
fml = stringToSyntaxbaum('!! A8');
val = rekursiv_depth(fml);
assert val == 2, 'computed {}'.format(val);
def test_calc3(self):
fml = string_to_parts('( ! A0 && A3 )');
fml = stringToSyntaxbaum('( ! A0 && A3 )');
val = rekursiv_depth(fml);
assert val == 2, 'computed {}'.format(val);
def test_calc4(self):
fml = string_to_parts('((( ! A0 && A3 ) || A4 ) && A8 )');
fml = stringToSyntaxbaum('((( ! A0 && A3 ) || A4 ) && A8 )');
val = rekursiv_depth(fml);
assert val == 4, 'computed {}'.format(val);
def test_calc5(self):
fml = string_to_parts('! ((( ! A0 && A3 ) || A4 ) && A8 )');
fml = stringToSyntaxbaum('! ((( ! A0 && A3 ) || A4 ) && A8 )');
val = rekursiv_depth(fml);
assert val == 5, 'computed {}'.format(val);
pass;
@ -87,32 +126,31 @@ class TestRekursivDepth(TestCase):
@unittest.skip('Methode noch nicht implementiert')
class TestRekursivLength(TestCase):
def test_calc1(self):
fml = string_to_parts('A0');
fml = stringToSyntaxbaum('A0');
val = rekursiv_length(fml);
assert val == 1, 'computed {}'.format(val);
def test_calc2(self):
fml = string_to_parts('!! A8');
fml = stringToSyntaxbaum('!! A8');
val = rekursiv_length(fml);
assert val == 3, 'computed {}'.format(val);
def test_calc3(self):
fml = string_to_parts('( ! A0 && A3 )');
fml = stringToSyntaxbaum('( ! A0 && A3 )');
val = rekursiv_length(fml);
assert val == 4, 'computed {}'.format(val);
def test_calc4(self):
fml = string_to_parts('((( ! A0 && A3 ) || A4 ) && A8 )');
fml = stringToSyntaxbaum('((( ! A0 && A3 ) || A4 ) && A8 )');
val = rekursiv_length(fml);
assert val == 8, 'computed {}'.format(val);
def test_calc5(self):
fml = string_to_parts('! ((( ! A0 && A3 ) || A4 ) && A8 )');
fml = stringToSyntaxbaum('! ((( ! A0 && A3 ) || A4 ) && A8 )');
val = rekursiv_length(fml);
assert val == 9, 'computed {}'.format(val);
pass;
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# TESTFALL Anzahl Klammern(·)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -120,67 +158,27 @@ class TestRekursivLength(TestCase):
@unittest.skip('Methode noch nicht implementiert')
class TestRekursivParentheses(TestCase):
def test_calc1(self):
fml = string_to_parts('A0');
fml = stringToSyntaxbaum('A0');
val = rekursiv_parentheses(fml);
assert val == 0, 'computed {}'.format(val);
def test_calc2(self):
fml = string_to_parts('!! A8');
fml = stringToSyntaxbaum('!! A8');
val = rekursiv_parentheses(fml);
assert val == 0, 'computed {}'.format(val);
def test_calc3(self):
fml = string_to_parts('( ! A0 && A3 )');
fml = stringToSyntaxbaum('( ! A0 && A3 )');
val = rekursiv_parentheses(fml);
assert val == 2, 'computed {}'.format(val);
def test_calc4(self):
fml = string_to_parts('((( ! A0 && A3 ) || A4 ) && A8 )');
fml = stringToSyntaxbaum('((( ! A0 && A3 ) || A4 ) && A8 )');
val = rekursiv_parentheses(fml);
assert val == 6, 'computed {}'.format(val);
def test_calc5(self):
fml = string_to_parts('! ((( ! A0 && A3 ) || A4 ) && A8 )');
fml = stringToSyntaxbaum('! ((( ! A0 && A3 ) || A4 ) && A8 )');
val = rekursiv_parentheses(fml);
assert val == 6, 'computed {}'.format(val);
pass;
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# TESTFALL eval(·, ·)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# @unittest.skip('Methode noch nicht implementiert')
class TestRekursivEval(TestCase):
def test_literale(self):
fml = string_to_parts('A0');
val = rekursiv_eval(fml, [ 'A0' ]);
assert val == 1;
fml = string_to_parts('A0');
val = rekursiv_eval(fml, []);
assert val == 0;
fml = string_to_parts('! A0');
val = rekursiv_eval(fml, [ 'A0' ]);
assert val == 0;
fml = string_to_parts('! A0');
val = rekursiv_eval(fml, []);
assert val == 1;
def test_complex1(self):
fml = string_to_parts('( ! A0 || (( A0 && A3 ) || A2 ))');
val = rekursiv_eval(fml, [ 'A0', 'A2' ]);
assert val == 1;
val = rekursiv_eval(fml, [ 'A0', 'A3' ]);
assert val == 1;
val = rekursiv_eval(fml, [ 'A0' ]);
assert val == 0;
val = rekursiv_eval(fml, [ 'A4', 'A8' ]);
assert val == 1;
def test_complex2(self):
fml = string_to_parts('( ! A0 || (( A0 && A3 ) || ! A2 ))');
val = rekursiv_eval(fml, [ 'A0', 'A2' ]);
assert val == 0;
val = rekursiv_eval(fml, [ 'A0', 'A3' ]);
assert val == 1;
pass;