implemented is tree like

Author: Theomat

grape/automaton/tree_automaton.py

@@ -409,7 +409,7 @@ def is_unbounded(self) -> bool:
         """
         Returns true if the grammar produces unbounded programs.
         """
-        reachable_from: dict[U, set[V]] = defaultdict(set)
+        reachable_from: dict[U, set[U]] = defaultdict(set)
         for (P, args), dst in self.rules.items():
             reachable_from[dst].update(args)
 
@@ -428,22 +428,8 @@ def is_unbounded(self) -> bool:
 
     def compute_max_size_and_depth(self) -> tuple[int, int]:
         """
-        Return max size and max depth
+        Return max size and max depth, this will loop endlessly if this grammar is unbounded.
         """
-        # Compute transitive closure
-        reachable_from: dict[U, set[V]] = defaultdict(set)
-        for (P, args), dst in self.rules.items():
-            reachable_from[dst].update(args)
-
-        updated = True
-        while updated:
-            updated = False
-            for dst, reachables in reachable_from.copy().items():
-                before = len(reachables)
-                for S in reachables.copy():
-                    reachables.update(reachable_from[S])
-                if len(reachables) != before:
-                    updated = True
         max_size_by_state: dict[U, int] = {state: 0 for state in self.states}
         max_depth_by_state: dict[U, int] = {state: 0 for state in self.states}
         for (P, args), dst in self.rules.items():
@@ -481,3 +467,58 @@ def __str__(self) -> str:
             lines.append(f"{dst} <- '{P}' {add}")
 
         return s + "\n".join(sorted(lines))
+
+    def has_unproductive_rules(self) -> bool:
+        """
+        Returns true iff a rule is unproductive (including unreachable).
+        """
+        new_states = self.states
+        new_rules = {
+            (letter, args): dst
+            for (letter, args), dst in self.rules.items()
+            if dst in new_states and all(s in new_states for s in args)
+        }
+        if new_rules != self.rules:
+            return True
+        consumed = self.__get_consumed__()
+        for _, dst in list(self.rules.items()):
+            if dst not in consumed:
+                return True
+
+        return False
+
+    def __has_cloning_derivation__(self) -> bool:
+        # Compute transitive closure
+        reachable_from: dict[U, set[U]] = defaultdict(set)
+        for (P, args), dst in self.rules.items():
+            reachable_from[dst].update(args)
+
+        updated = True
+        while updated:
+            updated = False
+            for dst, reachables in reachable_from.copy().items():
+                before = len(reachables)
+                for S in reachables.copy():
+                    reachables.update(reachable_from[S])
+                if len(reachables) != before:
+                    updated = True
+                    if dst in reachables and any(
+                        len(args) > 1
+                        for S in reachables
+                        for _, args in self.reversed_rules[S]
+                    ):
+                        return True
+        return False
+
+    def is_tree_like(self) -> bool:
+        """
+        Returns true iff all of the following are true:
+            - |derivations| >= |states| + 2
+            - there is no unusable production rules
+            - there is a derivation by transitive closure S ->* w S S
+        """
+        return (
+            self.size() >= len(self.all_states) + 2
+            and not self.has_unproductive_rules()
+            and self.__has_cloning_derivation__()
+        )

grape/cli/info.py

@@ -33,13 +33,14 @@ def main():
     print("rules:", dfta.size())
     print("symbols:", dfta.symbols())
     print("reduced:", old_rules == dfta.rules)
-    print("specialied:", specialized)
+    print("specialised:", specialized)
     if not dfta.is_unbounded():
         size, depth = dfta.compute_max_size_and_depth()
         print("max program size:", size)
         print("max program depth:", depth)
     else:
-        print("unbounded programs:", dfta.is_unbounded())
+        print("grammar produces unbounded programs")
+        print("tree like:", dfta.is_tree_like())
 
 
 if __name__ == "__main__":