Automata v.1.3.0

It has a precious implementation of Pushdown Automatas (PDA), deterministic and indeterministic. It also have an update of the rest of the classes, with a new method called [show], that prints on console the complete automata information. It also has a slight improvement on the examples printing, to be more fancy :3

Author: arhcoder

dfa-example-1.py

@@ -15,6 +15,7 @@
     Automata.addTransition(("q0", "b", "q0"))
     Automata.addTransition(("q1", "a", "q1"))
     Automata.addTransition(("q1", "b", "q1"))
+    Automata.show()
 
     #/ Executes the Automata:
     while True:
@@ -23,4 +24,6 @@
         if Automata.accepts(word, stepByStep=True):
             print(f"La cadena \"{word}\" SÍ es aceptada!")
         else:
-            print(f"La cadena \"{word}\" NO es aceptada!")
+            print(f"La cadena \"{word}\" NO es aceptada!")
+        print()
+        print("═"*40)

dfa-example-2.py

@@ -45,6 +45,7 @@
 
     #? Automata:
     Automata = DFA(Q, A, T, S, F)
+    Automata.show()
 
     #/ Executes the Automata:
     while True:
@@ -53,4 +54,6 @@
         if Automata.accepts(word, stepByStep=True):
             print(f"La cadena \"{word}\" SÍ es aceptada!")
         else:
-            print(f"La cadena \"{word}\" NO es aceptada!")
+            print(f"La cadena \"{word}\" NO es aceptada!")
+        print()
+        print("═"*40)

dfa.py

@@ -106,6 +106,22 @@ def setFinals(self, finals: set):
 
 
     #? Methods:
+    def show(self):
+        '''Prints Automata data'''
+        print()
+        print("═"*40)
+        print("\nAUTÓMATA FINITO DETERMINISTA\n")
+        print("═"*40)
+        print(f"\nEstados: {set(self.States)}")
+        print(f"Alfabeto: {set(self.Alphabet)}")
+        print(f"Estado inicial: \"{self.Initial}\"")
+        print(f"Estados finales: {set(self.Finals)}")
+        for t in self.Transitions:
+            t1 = t[1] if t[1] != "" else "λ"
+            print(f"* δ(\"{t[0]}\", \"{t1}\") = (\"{t[2]}\")")
+        print()
+        print("═"*40)
+
     def transite(self, symbol: str, printStep: bool = False):
         '''
             Recieves an actual reading symbol;
@@ -122,7 +138,7 @@ def transite(self, symbol: str, printStep: bool = False):
             if self.actual == transition[0] and symbol == transition[1]:
                 validTransitions.append(transition)
 
-        # If Automata has 0 or more than 1 transitions:
+        # If Automata has 0 or more than 1 transitions;
         if len(validTransitions) != 1:
             print(f" * Transición δ(\"{self.actual}\", \"{symbol}\") inválida!")
             self.error = True
@@ -132,7 +148,7 @@ def transite(self, symbol: str, printStep: bool = False):
             if printStep:
                 print(f" * \"{self.actual}\" lee \"{symbol}\" => \"{validTransitions[0][2]}\";")
             self.actual = validTransitions[0][2]
-
+    
     def accepts(self, string: str, stepByStep: bool = False):
         '''
             Recieves a string to read;
@@ -144,10 +160,16 @@ def accepts(self, string: str, stepByStep: bool = False):
         self.actual = self.Initial
         self.error = False
 
+        # It shows the step by step path for the string:
+        if stepByStep:
+            print(f"\nPara la cadena \"{string}\":\n")
+
         # Reads letter per letter:
         for character in string:
             self.transite(character, stepByStep)
 
+        print()
+        
         # If the string was accepted or not:
         # Firstly checks if transitionsCount == word lenght,
         # If not, is because it has an invalid transition:

nfa-example-1.py

@@ -2,35 +2,20 @@
 
 if __name__ == "__main__":
 
-    # First example of NFA Automata instance:
+    # Second example of NFA Automata instance:
     # Language of the Automata:
-    # L(Automata) = {aba(b^n): n>0} U
-    # {ab(a^n): n>=0};
-    #* States:
-    Q = {"q0", "qa", "qab", "qf", "qabf"}
-
-    #* Alphabet:
-    A = {"a", "b"}
-
-    #* Transitions:
-    T = []
-
-    #* Starting state:
-    S = "q0"
-
-    #* Finals states:
-    F = {"qf", "qabf"}
-
-    #* Transitions definition:
-    T.append( ("q0", "a", "qa") )
-    T.append( ("qa", "b", "qab") )
-    T.append( ("qab", "a", "qf") )
-    T.append( ("qf", "b", "qf") )
-    T.append( ("qab", "", "qabf") )
-    T.append( ("qabf", "a", "qabf") )
-
-    #? Automata:
-    Automata = NFA(Q, A, T, S, F)
+    # L(Automata) = {(a^n): n>=0} U {(b^n)a: n>=1};
+    Automata = NFA()
+    Automata.setStates({"q0", "qb", "qa", "qba"})
+    Automata.setAlphabet({"a", "b"})
+    Automata.setInitial("q0")
+    Automata.setFinals({"qa", "qba"})
+    Automata.addTransition(("q0", "", "qa"))
+    Automata.addTransition(("q0", "b", "qb"))
+    Automata.addTransition(("qa", "a", "qa"))
+    Automata.addTransition(("qb", "a", "qba"))
+    Automata.addTransition(("qb", "b", "qb"))
+    Automata.show()
 
     #/ Executes the Automata:
     while True:
@@ -39,4 +24,6 @@
         if Automata.accepts(word, stepByStep=True):
             print(f"La cadena \"{word}\" SÍ es aceptada!")
         else:
-            print(f"La cadena \"{word}\" NO es aceptada!")
+            print(f"La cadena \"{word}\" NO es aceptada!")
+        print()
+        print("═"*40)

nfa-example-2.py

@@ -2,19 +2,36 @@
 
 if __name__ == "__main__":
 
-    # Second example of NFA Automata instance:
+    # First example of NFA Automata instance:
     # Language of the Automata:
-    # L(Automata) = {(a^n): n>=0} U {(b^n)a: n>=1};
-    Automata = NFA()
-    Automata.setStates({"q0", "qb", "qa", "qba"})
-    Automata.setAlphabet({"a", "b"})
-    Automata.setInitial("q0")
-    Automata.setFinals({"qa", "qba"})
-    Automata.addTransition(("q0", "", "qa"))
-    Automata.addTransition(("q0", "b", "qb"))
-    Automata.addTransition(("qa", "a", "qa"))
-    Automata.addTransition(("qb", "a", "qba"))
-    Automata.addTransition(("qb", "b", "qb"))
+    # L(Automata) = {aba(b^n): n>0} U
+    # {ab(a^n): n>=0};
+    #* States:
+    Q = {"q0", "qa", "qab", "qf", "qabf"}
+
+    #* Alphabet:
+    A = {"a", "b"}
+
+    #* Transitions:
+    T = []
+
+    #* Starting state:
+    S = "q0"
+
+    #* Finals states:
+    F = {"qf", "qabf"}
+
+    #* Transitions definition:
+    T.append( ("q0", "a", "qa") )
+    T.append( ("qa", "b", "qab") )
+    T.append( ("qab", "a", "qf") )
+    T.append( ("qf", "b", "qf") )
+    T.append( ("qab", "", "qabf") )
+    T.append( ("qabf", "a", "qabf") )
+
+    #? Automata:
+    Automata = NFA(Q, A, T, S, F)
+    Automata.show()
 
     #/ Executes the Automata:
     while True:
@@ -23,4 +40,6 @@
         if Automata.accepts(word, stepByStep=True):
             print(f"La cadena \"{word}\" SÍ es aceptada!")
         else:
-            print(f"La cadena \"{word}\" NO es aceptada!")
+            print(f"La cadena \"{word}\" NO es aceptada!")
+        print()
+        print("═"*40)

nfa.py

@@ -110,6 +110,22 @@ def setFinals(self, finals: set):
 
 
     #? Methods:
+    def show(self):
+        '''Prints Automata data'''
+        print()
+        print("═"*40)
+        print("\nAUTÓMATA FINITO NO DETERMINISTA\n")
+        print("═"*40)
+        print(f"\nEstados: {set(self.States)}")
+        print(f"Alfabeto: {set(self.Alphabet)}")
+        print(f"Estado inicial: \"{self.Initial}\"")
+        print(f"Estados finales: {set(self.Finals)}")
+        for t in self.Transitions:
+            t1 = t[1] if t[1] != "" else "λ"
+            print(f"* δ(\"{t[0]}\", \"{t1}\") = (\"{t[2]}\")")
+        print()
+        print("═"*40)
+    
     def transite(self, symbol: str, printStep: bool = False):
         '''
             Recieves an catual reading symbol;
@@ -184,7 +200,10 @@ def accepts(self, string: str, stepByStep: bool = False):
         self.currents = [self.Initial]
         self.error = False
         self.correct = False
-        print()
+        
+        # It shows the step by step path for the string:
+        if stepByStep:
+            print(f"\nPara la cadena \"{string}\":\n")
 
         # If the string is empty:
         if len(string) == 0:

pda-example-1.py

@@ -0,0 +1,33 @@
+from pda import PDA
+
+if __name__ == "__main__":
+
+    # First example of PDA Automata instance:
+    # Language of the Automata:
+    # L(Automata) = { (a^n)(b^2n): n >= 0 };
+    # "ab" structure with the double of b's respect to a's.
+    # It includes the empty string.
+    Automata = PDA()
+    Automata.setStates({"q0", "qa", "qb", "qf"})
+    Automata.setAlphabet({"a", "b"})
+    Automata.setInitial("q0")
+    Automata.setFinals({"qf"})
+    Automata.addTransition(("q0", "a", "Z", "aaZ", "qa"))
+    Automata.addTransition(("qa", "a", "a", "aaa", "qa"))
+    Automata.addTransition(("qa", "b", "a", "", "qb"))
+    Automata.addTransition(("qb", "b", "a", "", "qb"))
+    Automata.addTransition(("qb", "", "Z", "", "qf"))
+    Automata.setStackAlphabet({"a", "Z"})
+    Automata.setInitialStack(["Z"])
+    Automata.show()
+
+    #/ Executes the Automata:
+    while True:
+        print()
+        word = input("Cadena: ")
+        if Automata.accepts(word, stepByStep=True):
+            print(f"La cadena \"{word}\" SÍ es aceptada!")
+        else:
+            print(f"La cadena \"{word}\" NO es aceptada!")
+        print()
+        print("═"*80)

pda-example-2.py

@@ -0,0 +1,62 @@
+from pda import PDA
+
+if __name__ == "__main__":
+
+    # Second example of PDA Automata instance:
+    # Language of the Automata:
+    # L(Automata) = { w c (w)^R: w in {a, b}* };
+    # Any "a" and "b" combination string (also empty),
+    # with then a "c", and then his reverse:
+
+    #* States:
+    Q = {"qw", "qc", "qf"}
+
+    #* Alphabet:
+    A = {"a", "b", "c"}
+
+    #* Transitions:
+    T = []
+
+    #* Starting state:
+    S = "qw"
+
+    #* Finals states:
+    F = {"qf"}
+
+    #* Stack alphabet:
+    X = {"Z", "1", "2"}
+
+    #* Initial stack:
+    I = ["Z"]
+
+    #* Transitions definition:
+    T.append( ("qw", "a", "Z", "1Z", "qw") )
+    T.append( ("qw", "b", "Z", "2Z", "qw") )
+    T.append( ("qw", "a", "1", "11", "qw") )
+    T.append( ("qw", "a", "2", "12", "qw") )
+    T.append( ("qw", "b", "1", "21", "qw") )
+    T.append( ("qw", "b", "2", "22", "qw") )
+
+    T.append( ("qw", "c", "1", "1", "qc") )
+    T.append( ("qw", "c", "2", "2", "qc") )
+    T.append( ("qw", "c", "Z", "Z", "qc") )
+
+    T.append( ("qc", "a", "1", "", "qc") )
+    T.append( ("qc", "b", "2", "", "qc") )
+
+    T.append( ("qc", "", "Z", "", "qf") )
+
+    #? Automata:
+    Automata = PDA(Q, A, T, S, F, X, I)
+    Automata.show()
+
+    #/ Executes the Automata:
+    while True:
+        print()
+        word = input("Cadena: ")
+        if Automata.accepts(word, stepByStep=True):
+            print(f"La cadena \"{word}\" SÍ es aceptada!")
+        else:
+            print(f"La cadena \"{word}\" NO es aceptada!")
+        print()
+        print("═"*40)