Refactor generators.

Author: rpgoldman

popper/abs_generate.py

@@ -0,0 +1,37 @@
+import abc
+
+
+class Generator(abc.ABC):
+
+    # @profile
+    def get_prog(self):
+        pass
+
+    def gen_symbol(self, literal, backend):
+        pass
+
+    def update_solver(self, size):
+        pass
+        self.update_number_of_literals(size)
+
+    def update_number_of_literals(self, size):
+        pass
+
+    def update_number_of_vars(self, size):
+        pass
+
+    def update_number_of_rules(self, size):
+        pass
+
+    def prune_size(self, size):
+        pass
+
+    # @profile
+    def get_ground_rules(self, rule):
+        pass
+
+    def parse_handles(self, new_handles):
+        pass
+
+    def constrain(self, tmp_new_cons):
+        pass

popper/gen2.py

@@ -8,7 +8,8 @@
 import pkg_resources
 from clingo import Function, Number, Tuple_
 
-from .util import Constraint, Literal
+from .util import Constraint, Literal, Settings
+from . abs_generate import Generator as AbstractGenerator
 
 
 def arg_to_symbol(arg):
@@ -20,7 +21,7 @@ def arg_to_symbol(arg):
         return Function(arg)
 
 
-def atom_to_symbol(pred, args):
+def atom_to_symbol(pred, args) -> Function:
     xs = tuple(arg_to_symbol(arg) for arg in args)
     return Function(name=pred, arguments=xs)
 
@@ -35,9 +36,10 @@ def atom_to_symbol(pred, args):
 """
 
 
-class Generator:
+class Generator(AbstractGenerator):
+    settings: Settings
 
-    def __init__(self, settings, bkcons=[]):
+    def __init__(self, settings: Settings, bkcons=[]):
         self.savings = 0
         self.settings = settings
         self.cached_clingo_atoms = {}
@@ -109,8 +111,8 @@ def __init__(self, settings, bkcons=[]):
 
         encoding = '\n'.join(encoding)
 
-        # with open('ENCODING-GEN.pl', 'w') as f:
-        # f.write(encoding)
+        with open('/tmp/ENCODING-GEN.pro', 'w') as f:
+            f.write(encoding)
 
         if self.settings.single_solve:
             solver = clingo.Control(['--heuristic=Domain', '-Wnone'])

popper/gen3.py

@@ -10,6 +10,8 @@
 import pkg_resources
 from collections import defaultdict
 from . util import rule_is_recursive, Constraint, Literal
+from . abs_generate import Generator as AbstractGenerator
+
 clingo.script.enable_python()
 from clingo import Function, Number, Tuple_
 from itertools import permutations
@@ -30,7 +32,7 @@ def atom_to_symbol(pred, args):
     xs = tuple(arg_to_symbol(arg) for arg in args)
     return Function(name = pred, arguments = xs)
 
-class Generator:
+class Generator(AbstractGenerator):
 
     def __init__(self, settings, bkcons=[]):
         self.settings = settings

popper/generate.py

@@ -14,6 +14,7 @@
 from clingo import Function, Number, Tuple_
 from itertools import permutations
 import dataclasses
+from . abs_generate import Generator as AbstractGenerator
 
 @dataclasses.dataclass(frozen=True)
 class Var:
@@ -75,7 +76,7 @@ def build_rule_literals(rule, rule_var, pi=False):
     if rule_is_recursive(rule):
         yield gteq(rule_var, 1)
 
-class Generator:
+class Generator(AbstractGenerator):
 
     def __init__(self, settings, bkcons=[]):
         self.savings = 0

popper/loop.py

@@ -2,17 +2,21 @@
 from collections import defaultdict
 from functools import cache
 from itertools import chain, combinations, permutations
+from typing import Any, List, Optional, Set, Tuple
 
 from bitarray.util import any_and, ones, subset
 
 from .bkcons import deduce_bk_cons, deduce_non_singletons, deduce_recalls, deduce_type_cons
 from .combine import Combiner
 from .tester import Tester
-from .util import Constraint, Literal, calc_prog_size, format_literal, format_prog, format_rule, get_raw_prog, \
+from .util import Constraint, Literal, Settings, calc_prog_size, format_literal, format_prog, format_rule, get_raw_prog, \
     mdl_score, order_prog, prog_has_invention, prog_is_recursive, remap_variables, rule_is_recursive, timeout
+from .abs_generate import Generator
+from .generate import Generator as Generator1
+from .gen2 import Generator as Generator2
+from .gen3 import Generator as Generator3
 
-
-def load_solver(settings, tester, coverage_pos, coverage_neg, prog_lookup):
+def load_solver(settings: Settings, tester: Tester, coverage_pos, coverage_neg, prog_lookup):
     if settings.debug:
         settings.logger.debug(f'Load exact solver: {settings.solver}')
 
@@ -67,7 +71,12 @@ def load_solver(settings, tester, coverage_pos, coverage_neg, prog_lookup):
 
 
 class Popper():
-    def __init__(self, settings, tester):
+    settings: Settings
+    tester: Tester
+    # the following 2 type hints are conjectural -- rpg
+    num_pos: int
+    num_neg: int
+    def __init__(self, settings: Settings, tester: Tester):
         self.settings = settings
         self.tester = tester
         self.pruned2 = set()
@@ -78,6 +87,21 @@ def __init__(self, settings, tester):
         self.tmp = {}
         self.seen_allsat = set()
 
+    def select_generator(self, bkcons):
+        settings = self.settings
+        gen: type[Generator]
+        if settings.single_solve:
+            gen = Generator2
+            settings.logger.debug("using generator 2")
+
+        elif settings.max_rules == 2 and not settings.pi_enabled:
+            gen = Generator3
+            settings.logger.debug("using generator 3")
+        else:
+            gen = Generator1
+            settings.logger.debug("using generate")
+        return gen(settings, bkcons)
+
     def run(self, bkcons):
 
         settings, tester = self.settings, self.tester
@@ -102,16 +126,7 @@ def run(self, bkcons):
         # generator that builds programs
         # AC: all very hacky until the refactoring is complete
         with settings.stats.duration('init'):
-            if settings.single_solve:
-                from .gen2 import Generator
-                print("using generator 2")
-            elif settings.max_rules == 2 and not settings.pi_enabled:
-                from .gen3 import Generator
-                print("using generator 3")
-            else:
-                from .generate import Generator
-                print("using generate")
-            generator = self.generator = Generator(settings, bkcons)
+            generator = self.generator = self.select_generator(bkcons)
 
         # track the success sets of tested hypotheses
 
@@ -173,7 +188,6 @@ def run(self, bkcons):
                 # generate a program
                 with settings.stats.duration('generate'):
                     prog = generator.get_prog()
-                    print("Generated prog: {}".format(prog))
                     settings.logger.info("Generated prog: {}".format(prog))
                     if prog is None:
                         break
@@ -203,7 +217,7 @@ def run(self, bkcons):
                                                                                                                  prog_size)
                     else:
                         pos_covered, inconsistent = tester.test_prog(prog)
-                        print(f"pos_covered: {pos_covered}, inconsistent: {inconsistent}")
+                        settings.logger.debug(f"pos_covered: {pos_covered}, inconsistent: {inconsistent}")
                         # @CH: can you explain these?
                         skipped, skip_early_neg = False, False
 
@@ -258,7 +272,8 @@ def run(self, bkcons):
                 if tp == num_pos:
                     add_gen = True
 
-                # if the program does not cover any positive examples, check whether it is has an unsat core
+                # if the program does not cover any positive examples, check whether
+                # it has an unsat core
                 if not has_invention:
                     if tp < min_coverage or (settings.noisy and tp <= prog_size):
                         with settings.stats.duration('find mucs'):
@@ -1560,8 +1575,10 @@ def popper(settings, tester, bkcons):
     Popper(settings, tester).run(bkcons)
 
 
-def get_bk_cons(settings, tester):
+def get_bk_cons(settings: Settings, tester: Tester):
     bkcons = []
+    recalls: Optional[List[str]]
+    pointless: Set[Tuple[str, Any]]
 
     with settings.stats.duration('find_pointless_relations'):
         pointless = settings.pointless = tester.find_pointless_relations()
@@ -1576,9 +1593,11 @@ def get_bk_cons(settings, tester):
     with settings.stats.duration('recalls'):
         recalls = deduce_recalls(settings)
 
-    if recalls == None:
+    if recalls is None:
+        settings.logger.debug('No recalls; datalog is False')
         settings.datalog = False
     else:
+        settings.logger.debug('Non-empty recalls: datalog is True')
         settings.datalog = True
         if settings.showcons:
             for x in recalls: