code/main.py

@@ -10,13 +10,12 @@ import os;
 import sys;
 sys.tracebacklimit = 0;
 from itertools import product;
-from lark import Tree;
-from textwrap import dedent;
 from typing import Dict;
 from typing import Generator;
 from typing import List;
 from typing import Tuple;
 from typing import Union;
+from lark import Tree;
 
 sys.path.insert(0, os.getcwd());
 
@@ -42,68 +41,32 @@ I = ['A0', 'A2'];
 
 def main():
     tree = string_to_parts(zeichenkette);
-    print(dedent(
-        '''
-        Syntaxbaum von
-            F := \033[92;1m{F}\033[0m:
-        '''.format(
-            F=zeichenkette,
-        )
-    ));
+    print('Syntaxbaum von \033[1m{}\033[0m:\n'.format(zeichenkette));
     print(tree.pretty());
-    print(dedent(
-        '''
-        eval(F, I)      = \033[94;1m{eval}\033[0m;
-        atoms(F)        = \033[94;1m{atoms}\033[0m; \033[91;1m<- *\033[0m
-        depth(F)        = \033[94;1m{d}\033[0m; \033[91;1m<- *\033[0m
-        length(F)       = \033[94;1m{l}\033[0m; \033[91;1m<- *\033[0m
-        #parentheses(F) = \033[94;1m{p}\033[0m; \033[91;1m<- *\033[0m
-
-        \033[91;1m*\033[0m \033[2mnoch nicht implementiert!\033[0m
-        \033[1;2;4mChallenge:\033[0m \033[2mschreibe diese Methoden. Probiere mit Stift-und-Zettel die Methoden händisch auszuführen und vergleiche mit dem Code-Output.\033[0m
-        '''.format(
-            eval  = rekursiv_eval(tree, I),
-            atoms = rekursiv_atoms(tree),
-            d     = rekursiv_depth(tree),
-            l     = rekursiv_length(tree),
-            p     = rekursiv_parentheses(tree),
-        )
-    ));
+    val = rekursiv_eval(tree, I)
+    print('eval(Formel, I) = \033[1m{}\033[0m'.format(val));
     return;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # SEKUNDÄRVORGÄNGE
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-def rekursiv_atoms(fml: Tree) -> List[str]:
-    ## Herausforderung: schreibe diese Funktion!
-    return [];
-
-def rekursiv_depth(fml: Tree) -> int:
-    ## Herausforderung: schreibe diese Funktion!
-    return 0;
-
-def rekursiv_length(fml: Tree) -> int:
-    ## Herausforderung: schreibe diese Funktion!
-    return 0;
-
-def rekursiv_parentheses(fml: Tree) -> int:
-    ## Herausforderung: schreibe diese Funktion!
-    return 0;
-
-def rekursiv_eval(fml: Tree, I: List[str]) -> int:
-    if fml.data in ['atom', 'beliebig']:
+def rekursiv_eval(fml: Tree, I: List[str]) -> bool:
+    if fml.data == 'atom':
         index = fml.children[0];
-        return 1 if ('{}'.format(index) in I) else 0;
+        return 'A{}'.format(index) in I;
+    elif fml.data == 'beliebig':
+        name = fml.children[0];
+        return '{}'.format(name) in I;
     elif fml.data == 'wahr':
-        return 1;
+        return True;
     elif fml.data == 'falsch':
-        return 0;
+        return False;
     elif fml.data == 'negation':
         teilformel1 = fml.children[1];
         if isinstance(teilformel1, Tree):
             val1 = rekursiv_eval(teilformel1, I);
-            return 1 - val1;
+            return not val1;
     elif fml.data == 'konjunktion':
         teilformel1 = fml.children[0];
         teilformel2 = fml.children[2];
@@ -124,7 +87,7 @@ def rekursiv_eval(fml: Tree, I: List[str]) -> int:
         if isinstance(teilformel1, Tree) and isinstance(teilformel2, Tree):
             val1 = rekursiv_eval(teilformel1, I);
             val2 = rekursiv_eval(teilformel2, I);
-            return 0 if val1 == 1 and val2 == 0 else 1;
+            return (val1 <= val2);
     else:
         raise Exception('Evaluation nicht möglich!');
     return True;

code/schema.py

@@ -33,7 +33,7 @@ lexerAussagenlogik = Lark(
     ?atomic:    false | true | atom | generic
     ?false:     "0"                         -> wahr
     ?true:      "1"                         -> falsch
-    ?atom:      /A[0-9]+/                -> atom
+    ?atom:      "A" /[0-9]+/                -> atom
     ?generic:   "{" /((?!({|})).)+/ "}"     -> beliebig
 
     // Symbole
@@ -44,8 +44,8 @@ lexerAussagenlogik = Lark(
 
     // Junktoren
     ?expr_not:     conn_not expr                -> negation
-    ?expr_and:     "(" expr conn_and   expr ")" -> konjunktion
-    ?expr_or:      "(" expr conn_or    expr ")" -> disjunktion
+    ?expr_and:     "(" expr conn_or    expr ")" -> konjunktion
+    ?expr_or:      "(" expr conn_and   expr ")" -> disjunktion
     ?expr_implies: "(" expr conn_impl  expr ")" -> implikation
     ''',
     start="expr",

protocol/woche4.md

@@ -1,6 +1,6 @@
 # Vorlesungswoche 4 (3. April – 9. Mai) #
 
-- [x] Organisatorisches (max. 5 min)
+- [ ] Organisatorisches (max. 5 min)
     - Hochladen = Abgeben
     - Zoom
         - Zugriff
@@ -12,45 +12,26 @@
         - Wohldefiniertheit: einfach!
     - bottom-up
         - wohlfundierte Relationen
-        - Wohldefiniertheit: (mühseliger!)
+        - Wohldefiniertheit: (schwer!)
     - Satz: bottom-up = top-down
-        - ⊇: weil bottom-up Eigenschaft hat und top-down kleinstmögliche Menge mit Eigenschaft ist.
-        - ⊆: (schwerer) zeige, dass alles in Klasse alle _n_-ten Stufen enthält, damit gilt Schnitt aus Klasse (=:top-down) enthält Vereinigung (=:bottom-up)
     - Präsentation (Schemata)
-        - für Mengen
-            - als Liste
-            - durch `"... | ... | ..."` Schreibweise
-        - für Funktionen
-            - definiere ƒ für Basisfälle.
-            - definiere ƒ für Zusammensetzung durch Werte von ƒ auf Teilen.
     - Beispiele:
-        - [x] ℕ als „kleinste Menge“, die 0 enthält und unter +1 abgeschlossen ist.
-        - [x] eval(·, I)
-        - [ ] Atome(·) -> kommt nächste Woche!
-        - [ ] Länge -> kommt nächste Woche!
+        - eval(·, I)
+        - Atome(·)
+        - Länge
     - Induktion
         - Aus Sicht von bottom-up (-> verallgemeinert Induktion über ℕ)
         - wieso funktioniert es? (Beweis durch Widerspruch -> betrachte `min{x | ¬ ф(x)}`)
-            - „min“ hier bzgl. x ≤ y ⟺ x (strikte) Teilformel von y
-            - alternativ bzgl. x ≤ y ⟺ |Zeichen in x|  < |Zeichen in y|
         - Beispiele
     - strukturelle Induktion
         - Aus Sicht von top-down (!! neue Sichtweise !!)
         - wieso funktioniert es? (direkter Beweis: `{x | ф(x)} ⊇ »kleinste Menge«`)
         - Beispiele
-- [x] weitere Fragen nach Aufzeichnungsende.
-    - wie verhält sich das mit Russellmenge?
-        -> „gelöst“ durch wohlfundiert/Wohlordnung
-        -> R keine Menge
-
+- [ ] weitere Fragen nach Aufzeichnungsende.
 
 ## Nächste Woche ##
 
-- Seminaraufgaben für Serie 2:
-    - KNF/DNF
-    - Hornformeln / Alg
-    - str. Induktion / Rekursion
-    - ~~Kompaktheit~~ (-> möglich nach der ÜG)
+- Seminaraufgaben für Serie 2
 
 ### TODOs (Studierende) ###