fixed issues with different types

Author: Theomat

grape/automaton_generator.py

@@ -60,19 +60,16 @@ def transition(p: Program, args: tuple[int, ...]) -> int | None:
     )
 
 
-def commutativity_constraint(
-    dsl: DSL, commutatives: list[tuple[str, list[int]]], type_req: str
-) -> Constraint:
-    arg_types, target_type = types.parse(type_req)
+def commutativity_constraint(commutatives: list[tuple[str, list[int]]]) -> Constraint:
     to_check: dict[str, list[tuple[int, int]]] = {}
     for p, swapped in commutatives:
         if p not in to_check:
             to_check[p] = []
         to_check[p].append((swapped[0], swapped[1]))
 
     def transition(p: Program, args: tuple[str, ...]) -> str | None:
-        if isinstance(p, Function):
-            key = str(p.function)
+        if isinstance(p, Primitive):
+            key = str(p)
             if key in to_check:
                 if all(args[i] <= args[j] for i, j in to_check[key]):
                     return key
@@ -83,17 +80,10 @@ def transition(p: Program, args: tuple[str, ...]) -> str | None:
         else:
             return str(p)
 
-    whatever = target_type.lower() == "none"
-
     return Constraint(
         str,
         transition,
-        lambda s: whatever
-        or (
-            types.return_type(dsl.primitives[s][0]) == target_type
-            if s in dsl.primitives
-            else arg_types[int(s[len("var") :])]
-        ),
+        lambda _: True,
     )
 
 
@@ -187,17 +177,17 @@ def grammar_from_memory(
     type_req: str,
     prev_finals: set[str],
 ) -> tuple[DFTA[str, Program], int]:
+    """
+    Returns (specialized grammar, 1)
+    """
     max_size = max(max(memory[state].keys()) for state in memory)
     args_type = types.arguments(type_req)
     # Compute variable merging: all variables of same type should be merged
-    var_merge = {}
     type2var = {}
-    for i, t in enumerate(args_type):
-        if t in type2var:
-            var_merge[i] = type2var[t]
-        else:
-            type2var[t] = i
-            var_merge[i] = i
+    for t in args_type:
+        if t not in type2var:
+            type2var[t] = len(type2var)
+    var_merge = {i: type2var[t] for i, t in enumerate(args_type)}
     # Produce rules incrementally
     rules: dict[tuple[Program, tuple[str, ...]], str] = {}
     finals: set[str] = set()
@@ -223,22 +213,22 @@ def grammar_from_memory(
 
     # Reproduce original type request to compare number of programs
     # add a rule for each deleted variable
-    added = set()
-    for i, j in var_merge.items():
-        if i == j:
-            continue
-        # data: variable i is renamed as variable j
-        old = Variable(i)
-        for (prog, _), dst in relevant_dfta.rules.copy().items():
-            if isinstance(prog, Variable) and prog.no == j:
-                relevant_dfta.rules[(old, ())] = dst
-                added.add((old, ()))
-    relevant_dfta.refresh_reversed_rules()
-    n = relevant_dfta.trees_until_size(max_size)
-    # Delete them now that they have been used
-    for x in added:
-        del relevant_dfta.rules[x]
-    relevant_dfta.refresh_reversed_rules()
+    # added = set()
+    # for i, j in var_merge.items():
+    #     if i == j:
+    #         continue
+    #     # data: variable i is renamed as variable j
+    #     old = Variable(i)
+    #     for (prog, _), dst in relevant_dfta.rules.copy().items():
+    #         if isinstance(prog, Variable) and prog.no == j:
+    #             relevant_dfta.rules[(old, ())] = dst
+    #             added.add((old, ()))
+    # relevant_dfta.refresh_reversed_rules()
+    # n = relevant_dfta.trees_until_size(max_size)
+    # # Delete them now that they have been used
+    # for x in added:
+    #     del relevant_dfta.rules[x]
+    # relevant_dfta.refresh_reversed_rules()
     # ==================================
 
-    return relevant_dfta, n
+    return relevant_dfta, 1

grape/cli/prune.py

@@ -118,7 +118,7 @@ def main():
         evaluator,
         manager,
         args.size,
-        target_type,
+        None,
         base_grammar,
     )
     type_req = type_request_from_specialized(reduced_grammar, dsl)

grape/pruning/obs_equiv_pruner.py

@@ -73,7 +73,7 @@ def __get_base_grammar__(
         grammar = grammar_by_saturation(
             dsl,
             type_req,
-            [commutativity_constraint(dsl, commutatives, type_req)],
+            [commutativity_constraint(commutatives)],
         )
     else:
         base_grammar = base_dfta
@@ -116,6 +116,8 @@ def prune(
         base_grammar,
         type_req,
     )
+    old_finals = grammar.finals.copy()
+    grammar.finals = set(grammar.all_states)
     enum_ntrees = grammar.trees_until_size(max_size)
     base_ntrees = sum(base_expected_trees.values())
 
@@ -170,9 +172,9 @@ def estimate_total(size: int) -> tuple[int, float]:
     pbar.update(n)
     pbar.close()
     evaluator.free_memory()
-    reduced_grammar, t = grammar_from_memory(
-        enumerator.memory, type_req, grammar.finals
-    )
+    grammar.finals = old_finals
+    reduced_grammar, t = grammar_from_memory(enumerator.memory, type_req, old_finals)
+    t = reduced_grammar.trees_until_size(max_size)
     print(f"at size {max_size} programs (after graping): {t:.2e}")
     print(
         "\tmethod: ratio no graping | ratio base | ratio graped",

tests/automaton/test_loop_manager.py

@@ -47,7 +47,10 @@ def signed_masking(n: int, mask: int = MAXI) -> int:
     return n & mask if n > 0 else -(-n & mask)
 
 
-sample_dict = {"int": lambda: signed_masking(random.randint(-MAXI, MAXI), MAXI)}
+sample_dict = {
+    "int": lambda: signed_masking(random.randint(-MAXI, MAXI), MAXI),
+    "bool": lambda: random.uniform(0, 1) > 0.5,
+}
 
 inputs = sample_inputs(50, sample_dict)
 
@@ -71,8 +74,7 @@ def signed_masking(n: int, mask: int = MAXI) -> int:
 max_size = 5
 manager = EquivalenceClassManager()
 evaluator = Evaluator(dsl, inputs, {}, set())
-out = prune(dsl, evaluator, manager, max_size=max_size, rtype="int")
-tr = "int->int"
+tr = "int->none"
 saturated = grammar_by_saturation(dsl, tr)
 
 
@@ -118,6 +120,7 @@ def comp_by_enum(grammars: list, tr: str, max_size: int):
 
 @pytest.mark.parametrize("algo", algorithms)
 def test_same_size(algo: LoopingAlgorithm):
+    out = prune(dsl, evaluator, manager, max_size=max_size)
     new_out = add_loops(out, dsl, algo)
     spec_out = respecialize(
         new_out, tr, type_request_from_specialized(new_out, dsl), dsl
@@ -127,6 +130,7 @@ def test_same_size(algo: LoopingAlgorithm):
 
 @pytest.mark.parametrize("algo", algorithms)
 def test_next_size(algo: LoopingAlgorithm):
+    out = prune(dsl, evaluator, manager, max_size=max_size)
     new_out = add_loops(out, dsl, algo)
     spec_out = respecialize(
         new_out, tr, type_request_from_specialized(new_out, dsl), dsl

tests/cli/test_prune.py

@@ -68,7 +68,6 @@ def signed_masking(n: int, mask: int = MAXI) -> int:
         ),
     }
 )
-evaluator = Evaluator(dsl, inputs, {}, set())
 max_size = 5
 algorithms = [LoopingAlgorithm.OBSERVATIONAL_EQUIVALENCE, LoopingAlgorithm.GRAPE]
 
@@ -121,26 +120,27 @@ def comp_by_enum(grammars: list, tr: str, max_size: int):
 
 def test_prune():
     manager = EquivalenceClassManager()
-    out = prune(dsl, evaluator, manager, max_size=max_size, rtype="int")
-    tr = "int->int"
+    evaluator = Evaluator(dsl, inputs, {}, set())
+    out = prune(dsl, evaluator, manager, max_size=max_size)
+    tr = "int->none"
     g = grammar_by_saturation(dsl, tr)
     spec_out = respecialize(out, tr, type_request_from_specialized(out, dsl), dsl)
     comp_by_enum([spec_out, g], tr, max_size)
 
 
 def test_incremental_same_size():
     manager = EquivalenceClassManager()
-    out = prune(dsl, evaluator, manager, max_size=max_size, rtype="int")
-    incremental = prune(
-        dsl, evaluator, manager, max_size=max_size, rtype="int", base_grammar=out
-    )
+    evaluator = Evaluator(dsl, inputs, {}, set())
+    out = prune(dsl, evaluator, manager, max_size=max_size)
+    incremental = prune(dsl, evaluator, manager, max_size=max_size, base_grammar=out)
     assert out.rules == incremental.rules
     assert out.finals == incremental.finals
 
 
 @pytest.mark.parametrize("algo", algorithms)
 def test_incremental_same_size_with_loops(algo: LoopingAlgorithm):
     manager = EquivalenceClassManager()
+    evaluator = Evaluator(dsl, inputs, {}, set())
     out = prune(dsl, evaluator, manager, max_size=max_size, rtype="int")
     out = add_loops(out, dsl, algo)
 
@@ -157,14 +157,14 @@ def test_incremental_same_size_with_loops(algo: LoopingAlgorithm):
 def test_incremental_next_size(algo: LoopingAlgorithm):
     manager = EquivalenceClassManager()
     evaluator = Evaluator(dsl, inputs, {}, set())
-    out = prune(dsl, evaluator, manager, max_size=max_size, rtype="int")
+    out = prune(dsl, evaluator, manager, max_size=max_size)
     out = add_loops(out, dsl, algo)
     evaluator.free_memory()
     incremental = prune(
-        dsl, evaluator, manager, max_size=max_size + 1, rtype="int", base_grammar=out
+        dsl, evaluator, manager, max_size=max_size + 1, base_grammar=out
     )
     evaluator.free_memory()
-    direct = prune(dsl, evaluator, manager, max_size=max_size + 1, rtype="int")
+    direct = prune(dsl, evaluator, manager, max_size=max_size + 1)
     comp_by_enum(
         [incremental, direct], type_request_from_specialized(direct, dsl), max_size + 1
     )
@@ -174,8 +174,8 @@ def test_is_superset():
     evaluator = Evaluator(dsl, inputs, {}, set())
 
     manager = EquivalenceClassManager()
-    out = prune(dsl, evaluator, manager, max_size=max_size, rtype="int")
-    tr = "int->int"
+    out = prune(dsl, evaluator, manager, max_size=max_size)
+    tr = "int->none"
     base = grammar_by_saturation(dsl, tr)
     evaluator = Evaluator(dsl, inputs, {}, set())
     ebase = Enumerator(base)