Added skip_example feature. This enables per-instance multipliers and also so we do not *have* to test the example. Also updated readme format

Author: akalai

README.md

@@ -115,7 +115,7 @@ A more challenging puzzle that requires [dynamic programming](https://en.wikiped
 [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) problem
 which we can also describe with strings:
 ```python
-def f(x: List[int], length=20, s="Dynamic programming solves this classic job-interview puzzle!!!"):
+def sat(x: List[int], length=20, s="Dynamic programming solves this classic job-interview puzzle!!!"):
     """Find the indices of the longest substring with characters in sorted order"""
     return all(s[x[i]] <= s[x[i + 1]] and x[i + 1] > x[i] for i in range(length - 1))
 
@@ -179,7 +179,7 @@ During a Microsoft hackathon July 27-29, 2020, several people completed 30 user
 [Hackathon_puzzles.ipynb](/notebooks/Hackathon_puzzles.ipynb). These are of a somewhat
 different flavor as they are more often `hacks` like 
 ```python
-def f(x):
+def sat(x):
     return x > x
 ```
 where the type of `x` is clearly non-standard. The creators of these puzzles include github users: 

generators/IMO.py

@@ -20,7 +20,7 @@ class ExponentialCoinMoves(PuzzleGenerator):
 
     Inspired by [IMO 2010 Problem 5](https://www.imo-official.org/problems.aspx)"""
 
-    multiplier = 10  # worth 10 times normal so that it can run 10 times longer than normal
+    skip_example = True  # so that we can add a multiplier in gen method below
 
     @staticmethod
     def sat(states: List[List[int]], n=16385):
@@ -88,9 +88,10 @@ def exp_move():  # shifts last 3 [..., a, 0, 0] to [..., 0, 2^a, 0] for a>0
         return ans
 
     def gen(self, target_num_instances):
+        self.add(dict(n=2**14 + 1), multiplier=10) # n=16385 will be first instance because of skip_example
         for i in range(10):
             n = 2 ** i
-            self.add(dict(n=n))
+            self.add(dict(n=n), multiplier=1 if n <= 4 else n)
 
 
 class NoRelativePrimes(PuzzleGenerator):

generators/classic_puzzles.py

@@ -1,5 +1,4 @@
-"""Classic puzzles
-"""
+"""Classic puzzles"""
 
 from puzzle_generator import PuzzleGenerator
 from typing import List

generators/games.py

@@ -19,7 +19,7 @@ class Nim(PuzzleGenerator):
     them to determine winning states or beat a certain opponent.
     """
 
-    value_multiplier = 10  # harder than most problems, worth more
+    skip_example = True  # so we can add multiplier in gen method below
 
     @staticmethod
     def sat(moves: List[List[int]], initial_state=[5, 9, 3, 11, 18, 25, 1, 2, 4, 1]):
@@ -79,6 +79,9 @@ def optimal_move():
                 return moves
             bot_move()
 
+    def gen(self, target_num_instances):
+        self.add(self.get_example(), multiplier=10)
+
     def gen_random(self):
         def losing(h):  # return True if h is a losing state
             xor = 0
@@ -94,7 +97,7 @@ def losing(h):  # return True if h is a losing state
         for i in initial_state:
             prod *= i + 1
         if prod < 10 ** 6:
-            self.add(dict(initial_state=initial_state))
+            self.add(dict(initial_state=initial_state), multiplier=10 if prod > 1000 else 1)
 
 
 class Mastermind(PuzzleGenerator):
@@ -105,7 +108,7 @@ class Mastermind(PuzzleGenerator):
     them to provide a provable winning game tree.
     """
 
-    multiplier = 10  # hard puzzle, takes longer to test
+    skip_example = True  # so we can add multiplier in gen method below
 
     @staticmethod
     def sat(transcripts: List[str], max_moves=10):
@@ -191,8 +194,8 @@ def max_ambiguity(guess):
         return transcripts
 
     def gen(self, target_num_instances):
-        for max_moves in [6, 8, 10]:
-            self.add(dict(max_moves=max_moves))
+        for max_moves in [10, 8, 6]:
+            self.add(dict(max_moves=max_moves), multiplier=30 - 2 * max_moves)
 
 
 class TicTacToeX(PuzzleGenerator):
@@ -315,17 +318,16 @@ def sol():
         return [1 / 3] * 3
 
 
-
 class Nash(PuzzleGenerator):
     """Computing a [Nash equilibrium](https://en.wikipedia.org/wiki/Nash_equilibrium) for a given
      [bimatrix game](https://en.wikipedia.org/wiki/Bimatrix_game) is known to be
      PPAD-hard in general. However, the challenge is be much easier for an approximate
      [eps-equilibrium](https://en.wikipedia.org/wiki/Epsilon-equilibrium) and of course for small games."""
 
-    multiplier = 10
+    skip_example = True  # so we can add multiplier in gen method below
 
     @staticmethod
-    def sat(strategies: List[List[float]], A = [[1.0, -1.0], [-1.3, 0.8]], B = [[-0.9, 1.1], [0.7, -0.8]], eps=0.01):
+    def sat(strategies: List[List[float]], A=[[1.0, -1.0], [-1.3, 0.8]], B=[[-0.9, 1.1], [0.7, -0.8]], eps=0.01):
         """
         Find an eps-Nash-equilibrium for a given two-player game with payoffs described by matrices A, B.
         For example, for the classic Prisoner dilemma:
@@ -373,13 +375,16 @@ def sat(strategies: List[List[float]], A, B, eps):
             if sat(strategies, A, B, eps):
                 return strategies
 
+    def gen(self, target_num_instances):
+        self.add(self.get_example(), multiplier=5)
+
     def gen_random(self):
         m = self.random.randrange(2, 10)
         n = self.random.randrange(2, 10)
         A, B = [[[self.random.random() for _i in range(m)] for _j in range(n)] for _k in range(2)]
         eps = self.random.choice([0.5, 0.1, 0.01])
         solved = self.sol(A, B, eps) is not None
-        self.add(dict(A=A, B=B, eps=eps), test=solved)
+        self.add(dict(A=A, B=B, eps=eps), test=solved, multiplier=5)
 
 
 class ZeroSum(PuzzleGenerator):
@@ -390,7 +395,7 @@ class ZeroSum(PuzzleGenerator):
      more efficient algorithms would be needed."""
 
     @staticmethod
-    def sat(strategies: List[List[float]], A = [[0., -0.5, 1.], [0.75, 0., -1.], [-1., 0.4, 0.]], eps=0.01):
+    def sat(strategies: List[List[float]], A=[[0., -0.5, 1.], [0.75, 0., -1.], [-1., 0.4, 0.]], eps=0.01):
         """
         Compute minimax optimal strategies for a given zero-sum game up to error tolerance eps.
         For example, rock paper scissors has
@@ -407,7 +412,7 @@ def sat(strategies: List[List[float]], A = [[0., -0.5, 1.], [0.75, 0., -1.], [-1
 
     @staticmethod
     def sol(A, eps):
-        MAX_ITER = 10**4
+        MAX_ITER = 10 ** 4
         m, n = len(A), len(A[0])
         a = [0 for _i in range(m)]
         b = [0 for _j in range(n)]

generators/lattices.py

@@ -18,27 +18,8 @@ class LearnParity(PuzzleGenerator):
     The vectors are encoded as binary integers for succinctness.
     """
 
-    # vecs below generated by vecs = LearnParity.rand_parity_problem(random.Random(28562407), d=63)
-
     @staticmethod
-    def sat(inds: List[int], vecs=[8543342634111025532, 8335192666369313368, 2359039407982105779, 4172548441791366513,
-                                   1256349095522986569, 3754463859322679595, 1562879970152915618, 1933016518061876369,
-                                   5920060919607788629, 8545759471656960221, 2934241949774725291, 559495833580308526,
-                                   5239436672544732707, 5865707252111994906, 8310678944230832071, 4595527784831581592,
-                                   4348871153851862010, 5198370132175169882, 3748480974791545460, 1215135748294622536,
-                                   4321487173746421746, 9012812639700145153, 588387599697000986, 5003829835901037543,
-                                   7754881381173342129, 2635789994388296837, 3222773777603033590, 5790284924977099989,
-                                   7540575369379211274, 7898971930608516039, 27260728996582582, 1792453914477410383,
-                                   8726418386455953809, 9193001185022172125, 3515388340741601364, 6217726337930929836,
-                                   1038687698871580494, 1892601486162604802, 3633356355444530940, 108334555669330693,
-                                   1955821183884414243, 5681081121990060330, 5791800194327455183, 8459367068223249929,
-                                   4271428016720060690, 913733008909519396, 2233236350093301187, 6538503022239131288,
-                                   5292485269677307644, 4615671355181378169, 2605305508625596241, 4954529961471509975,
-                                   2312963580097644831, 888555840551788245, 4152336321587083789, 8978251650218883651,
-                                   2567641184250287470, 2168893575221172018, 4358821646257958779, 3102433300308778243,
-                                   4185793889128296420, 6687096428156463254, 4143873353280484310, 8454616559174688585,
-                                   6589014033410725016, 5903549622062684554, 2388718494916838667, 8850145667696469408,
-                                   5068285804151890745, 2981241929741282230, 79408177335937724, 1711542430102927280]):
+    def sat(inds: List[int], vecs=[169, 203, 409, 50, 37, 479, 370, 133, 53, 159, 161, 367, 474, 107, 82, 447, 385]):
         """
         Parity learning: Given binary vectors in a subspace, find the secret set S of indices such that:
         $\\sum_{i \in S} x_i = 1 (mod 2)$
@@ -76,22 +57,25 @@ def sol(vecs):
 
     @staticmethod
     def rand_parity_problem(rand, d=63):
-        secret = None
-        while not secret:
-            secret = [i for i in range(d) if rand.randrange(2)]
+        secret = rand.sample(range(d), d // 2)
         num_vecs = d + 9
         vecs = [[rand.randrange(2) for _ in range(d)] for i in range(num_vecs)]
         for v in vecs:
             v[secret[0]] = (1 + sum([v[i] for i in secret[1:]])) % 2
         vecs = [sum(1 << i for i, b in enumerate(v) if b) for v in vecs]  # encode into ints
         return vecs
 
+    def gen(self, target_num_instances):
+        vecs = self.rand_parity_problem(self.random, d=63)
+        self.add(dict(vecs=vecs), multiplier=10)
+
     def gen_random(self):
+        d = self.random.randrange(2, self.random.choice([5, 10, 20, 100]))
         vecs = self.rand_parity_problem(
             self.random,
-            d=self.random.randrange(2, self.random.choice([5, 10, 20, 100]))
+            d=d,
         )
-        self.add(dict(vecs=vecs))
+        self.add(dict(vecs=vecs), multiplier=10 if d > 9 else 1)
 
 
 class LearnParityWithNoise(PuzzleGenerator):
@@ -101,44 +85,8 @@ class LearnParityWithNoise(PuzzleGenerator):
     [Parity learning problem](https://en.wikipedia.org/w/index.php?title=Parity_learning)
     runs in time $2^(d/(log d))$"""
 
-    # vecs below generated by LearnParityWithNoise.rand_parity_problem(random.Random(852352407), d=63)
-
-    multiplier = 40  # hard puzzle, takes longer to test
-
     @staticmethod
-    def sat(inds: List[int], vecs=[2874444459419665109, 3571416480966091062, 3627516422625241827, 2417762213996395207,
-                                   4371357242721531635, 1396026910505373292, 6671557086560014752, 9066082518122683098,
-                                   5240053591369828114, 8556210480838058892, 7302977584273736381, 8938278934736014411,
-                                   4398671200512032996, 6147375266514044469, 6609538006889421793, 2297823643430705118,
-                                   7583979108118079257, 2498392101379258437, 7893501751515236283, 2027235323873165116,
-                                   925357965000140266, 9009345166609418406, 5689450111800001849, 2079746314404416253,
-                                   4228649029862868917, 5819371323838727219, 102386757609774316, 5480808186035115654,
-                                   3001738569073502536, 9059061077086189682, 681271298018419415, 5616731111115463763,
-                                   2722737236861682531, 4918075690687573998, 7125583379861998376, 7968096465923567867,
-                                   898679944061110348, 1140358409311167922, 6077294650144352445, 587776882127248609,
-                                   2018954969823094844, 1618480274277140739, 8884189689498565225, 4084721521520724931,
-                                   4718438135662169666, 8411612063174086200, 8726374275365985960, 3135872851883336005,
-                                   1091802941995014823, 4944178741300545327, 6970959994566965947, 2911632933598497473,
-                                   8638215954009823387, 7438975146059987571, 3486356869336916018, 4935404783245269300,
-                                   3492912640500734004, 7903591215281799872, 4616161610863395412, 875020887047334808,
-                                   2721628497281503934, 6882639287577667047, 6274957618887284536, 3575443754501116278,
-                                   2031604067526359716, 4433373641914130623, 6204772769819600658, 8509292558066435714,
-                                   1857073904365563798, 7875287918949902618, 5205034693823928900, 4943396962875355147,
-                                   2805601192218759148, 8976171820624983460, 5930936964665834653, 949687393644726240,
-                                   6466615045398392331, 423404729770342491, 2720698610804800422, 7479269416044676778,
-                                   7869290888646534505, 6327163107872545492, 476579447640475544, 1218066186129904051,
-                                   7630726053076756205, 7741086216563432736, 5225376670650457287, 7040078265943665053,
-                                   2162853338175426448, 5633819254572300801, 92334600849454176, 9098183941628882647,
-                                   3481731752092062852, 5473741255745389738, 7266470290696653678, 3090338455353169956,
-                                   4358343354422765853, 3623553173494979282, 8328390749513844747, 2287762878756609646,
-                                   4126189061710502597, 5829472669961813184, 7342395882491704275, 5030578088617810038,
-                                   2210525427289006508, 6161187897225224000, 5601573223749212224, 6539026784581543793,
-                                   3571032801838391198, 4813662449014287760, 6577243754700968179, 4401899289452367605,
-                                   305529480505303551, 1548494450097231731, 6926707725781258948, 6357305518384676781,
-                                   6357665620505806556, 1554358231697328409, 7871587375269472810, 2094942344314098945,
-                                   1452972368095860063, 3210274450167364491, 6901356410911155351, 7609098874470545378,
-                                   6955802737127492446, 6919896432783547538, 5423154486785623318, 3105394980859157674,
-                                   8438962979748731599, 4110730383299136510, 6718356757580670867]):
+    def sat(inds: List[int], vecs=[26, 5, 32, 3, 15, 18, 31, 13, 24, 25, 34, 5, 15, 24, 16, 13, 0, 27, 37]):
         """
         Learning parity with noise: Given binary vectors, find the secret set $S$ of indices such that, for at least
         3/4 of the vectors, $$sum_{i \in S} x_i = 1 (mod 2)$$
@@ -158,18 +106,15 @@ def sol(vecs):
         import random
         rand = random.Random(0)
         target = (len(vecs) * 3) // 4
-        max_attempts = 10**4
+        max_attempts = 10 ** 5
         for _ in range(max_attempts):
             ans = [i for i in range(d) if rand.randrange(2)]
             if sum(sum(v[i] for i in ans) % 2 for v in vecs) >= len(vecs) * 3 / 4:
                 return ans
 
     @staticmethod
     def rand_parity_problem(rand, d=63):
-        secret = None
-        while not secret:
-            secret = [i for i in range(d) if rand.randrange(2)]
-        print(len(secret))
+        secret = rand.sample(range(d), d // 2)
         num_vecs = 2 * d + 5
         vecs = [[rand.randrange(2) for _ in range(d)] for i in range(num_vecs)]
         for v in vecs:
@@ -180,17 +125,17 @@ def rand_parity_problem(rand, d=63):
         vecs = [sum(1 << i for i, b in enumerate(v) if b) for v in vecs]  # encode into ints
         return vecs
 
-    def testable(self, inp: dict):
-        return max(inp["vecs"]) < 2 ** 20
+    def gen(self, target_num_instances):
+        vecs = self.rand_parity_problem(self.random, d=63)
+        self.add(dict(vecs=vecs), test=False, multiplier=1000)
 
     def gen_random(self):
         d = self.random.randrange(2, self.random.choice([11, 100]))  # number of dimensions
         vecs = self.rand_parity_problem(
             self.random,
             d=d
         )
-        self.add(dict(vecs=vecs), test=d < 19)
-
+        self.add(dict(vecs=vecs), test=d < 19, multiplier=1000 if d > 40 else 30 if d >= 19  else 1)
 
-if __name__ == "__main__":
-    PuzzleGenerator.debug_problems()
+    if __name__ == "__main__":
+        PuzzleGenerator.debug_problems()