fixing vstructures bugs a bit

pysemigroup/parsers/utils.py

@@ -5,22 +5,40 @@ import pysemigroup
 
 
 class TreeToHashable(Transformer):
-    string = lambda _, e: "".join(map(str, e))
-    number = lambda _, e: int(e[0])
-    float = lambda _, e: float(e[0])
-    tuple = lambda _, e: tuple(e)
-    set = lambda _, e: frozenset(e)
+    def string(self, e):
+        return "".join(map(str, e))
+
+    def number(self, e):
+        return int(e[0])
+
+    def float(self, e):
+        return float(e[0])
+
+    def tuple(self, e):
+        return tuple(e)
+
+    def set(self, e):
+        return frozenset(e)
 
 
 HashableTree = TreeToHashable()
 
 
 class TreeSubmoduleToHashable(Transformer):
-    utils__string = lambda _, e: "".join(map(str, e))
-    utils__number = lambda _, e: int(e[0])
-    utils__float = lambda _, e: float(e[0])
-    utils__tuple = lambda _, e: tuple(e)
-    utils__set = lambda _, e: frozenset(e)
+    def utils__string(self, e):
+        return "".join(map(str, e))
+
+    def utils__number(self, e):
+        return int(e[0])
+
+    def utils__float(self, e):
+        return float(e[0])
+
+    def utils__tuple(self, e):
+        return tuple(e)
+
+    def utils__set(self, e):
+        return frozenset(e)
 
 
 HashableTreeSubmodule = TreeSubmoduleToHashable()

pysemigroup/tests/test_automata.py

 import pytest
 from pysemigroup import automata
-from pysemigroup.views import StateView, AlphabetView, ε, Epsilon
+from pysemigroup.views import StateView, AlphabetView, ε
 from pysemigroup.automata import sorted_transitions
 import itertools
 import networkx as nx
 
 
-class TestEpsilon:
-    def test_equality(self):
-        E1 = Epsilon()
-        E2 = Epsilon()
-        assert E1 == E2
-        assert E1 == ε
-
-    def test_hash(self):
-        E1 = Epsilon()
-        E2 = Epsilon()
-        assert hash(E1) == hash(E2)
-        assert hash(ε) == hash(E2)
-
-    def test_repr(self):
-        assert str(ε) == "ε"
-
-
 class TestTransitions:
     def test_hash(self):
         iter_transitions = [(0, "a", 1), (0, "a", 2), (1, "b", 2), (1, ε, 0)]

pysemigroup/views.py

 import random
 from typing import (
     ClassVar,
+    Iterator,
+    Self,
 )
 
 
-class View:
+class View(frozenset):
     def __repr__(self):
         return f"{self.__class__.__name__}({self.subrepr()})"
 
@@ -12,16 +14,26 @@ class View:
         s = ", ".join(map(str, self))
         return f"{{{s}}}"
 
+    def powerset(self) -> Iterator[Self]:
+        if not self:
+            yield type(self)("")
+            return
+        el = next(iter(self))
+        V = View(self.difference((el,)))
+        for S in V.powerset():
+            yield S
+            yield type(self)(S.union((el,)))
 
-class StateView(View, frozenset):
+
+class StateView(View):
     ...
 
 
-class C(frozenset, View):
+class C(View):
     ...
 
 
-class AlphabetView(frozenset):
+class AlphabetView(View):
     def compute_salt(self, retry=4):
         salt = random.randint(0, MAX_INT)
         S = set(map(lambda e: hash((e, salt)), self))

pysemigroup/vstructure.py

 from pysemigroup import RegularLanguage, DFA, NFA
-from typing import Iterable, Hashable
+from typing import Iterable, Hashable, Tuple, Self
 from pysemigroup.view import AlphabetView
+from pysemigroup.errors import VStructureLetterError
 
 
 class VStructureAlphabet:
@@ -30,8 +31,8 @@ class VStructureAlphabet:
 
     def __iter__(self):
         for letter in self.alphabet:
-            for FOvar in powerset(self.first_order_variable):
-                for MSOvar in powerset(self.second_order_variable):
+            for FOvar in self.first_order_variable.powerset():
+                for MSOvar in self.second_order_variable.powerset():
                     yield VStructureLetter(letter, FOvar, MSOvar, self)
 
     def __state__(self) -> Tuple[type, AlphabetView, AlphabetView, AlphabetView]:
@@ -46,7 +47,7 @@ class VStructureAlphabet:
         return self.__state__() == other.__state__()
 
     def validation_language(self):
-        states = powerset(self.first_order_variable)
+        states = self.first_order_variable.powerset()
         transitions = [
             (state, letter, state.union(letter.first_order_variable))
             for state in states
@@ -73,7 +74,7 @@ class VStructureLetter:
         self._valphabet = valphabet
 
         if (
-            not fist_order_variables.is_subset(valphabet.first_order_variable)
+            not first_order_variable.is_subset(valphabet.first_order_variable)
             or not second_order_variable.is_subset(valphabet.second_order_variable)
             or base_letter not in valphabet.alphabet
         ):