Complete for string DSL

README.md

@@ -35,13 +35,19 @@ optional arguments:
                         Domain of synthesis (either "arithmetic" or "string").
   --examples {addition,subtraction,multiplication,division}
                         Examples to synthesize program from. Must be a valid key in the "example_set" dictionary.
-  --max_weight MAX_WEIGHT
+  --max-weight MAX_WEIGHT
                         Maximum weight of programs to consider before terminating search.
 ```
 
 For example, to synthesize programs in the arithmetic domain from the addition input-output examples, run:
 ```
-python3 synthesis.py --domain arithmetic --examples addition
+python synthesis.py --domain arithmetic --examples addition
+- Extracted 9 constants from examples.
+- Searching level 2 with 9 primitives.
+Program found in 0.0116s.
+Program: (x0 + x1)
+Program weight: 3
+Program return type: int
 ```
 
 To add additional input-output examples, modify `examples.py`. Add a new key to the dictionary `example_set` and set the value to be a list of tuples.

arithmetic.py

@@ -13,21 +13,10 @@ class IntegerVariable:
     For example, if the input is [4, 5, 6] and the variable is the third element (i.e., 6), then position = 2.
     '''
     def __init__(self, position):
-        # self.value = None           # value of the variable, initially None
         self.position = position    # zero-indexed position of the variable in the arguments to program
         self.type = int             # type of the variable
         self.weight = 1             # weight of the variable
 
-    # def assign(self, value):
-    #     self.value = value
-
-    # def evaluate(self, input = None):
-    #     # check that variable has been assigned a value
-    #     if self.value is None:
-    #         raise ValueError(f"Variable {self.position} has not been assigned a value.")
-
-    #     return self.value
-
     def evaluate(self, input = None):
 
         # check that input is not None

examples.py

@@ -11,13 +11,18 @@ function in the synthesizer.
 
 # define examples
 example_set = {
-    # arithmetic examples
+    # basic arithmetic examples
     'addition': [([7, 2], 9), ([8, 1], 9), ([3, 9], 12), ([5, 8], 13)], # ([4, 6], 10), 
     'subtraction': [([9, 2], 7), ([6, 1], 5), ([7, 3], 4), ([8, 4], 4), ([10, 2], 8)],
     'multiplication': [([2, 3], 6), ([4, 5], 20), ([7, 8], 56), ([9, 2], 18), ([3, 4], 12)],
-    'division': [([6, 2], 3), ([8, 4], 2), ([9, 3], 3), ([10, 5], 2), ([12, 6], 2)]
+    'division': [([6, 2], 3), ([8, 4], 2), ([9, 3], 3), ([10, 5], 2), ([12, 6], 2)],
+
+    # complex arithmetic examples
+    'add_5_multiply_2': [([1, 2], 12), ([3, 4], 22), ([5, 6], 32), ([7, 8], 42), ([9, 10], 52)],
+    'multiply_add_9': [([1, 2], 11), ([3, 4], 21), ([5, 6], 39), ([7, 8], 65), ([9, 10], 9)],
 
     # string examples
+    'concatenate': [(["a", "b"], "ab"), (["c", "d"], "cd"), (["e", "f"], "ef")],
 
     # custom user examples
 }

strings.py

@@ -0,0 +1,112 @@
+'''
+STRING OPERATORS
+This file contains Python classes that define the string operators for program synthesis.
+'''
+
+'''
+CLASS DEFINITIONS
+''' 
+
+class StringVariable:
+    '''
+    Class to represent an string variable. Note that position is the position of the variable in the input.
+    For example, if the input is ["a", "b", "c"] and the variable is the third element (i.e., "c"), then position = 2.
+    '''
+    def __init__(self, position):
+        self.position = position    # zero-indexed position of the variable in the arguments to program
+        self.type = str             # type of the variable
+        self.weight = 1             # weight of the variable
+
+    def evaluate(self, input = None):
+
+        # check that input is not None
+        if input is None:
+            raise ValueError("Input is None.")
+
+        # check that input is a list
+        if type(input) != list:
+            raise ValueError("Input is not a list.")
+
+        # check that input is not empty
+        if len(input) == 0:
+            raise ValueError("Input is empty.")
+
+        # check that position is valid
+        if self.position >= len(input):
+            raise ValueError(f"Position {self.position} is out of range for input of length {len(input)}.")
+
+        return input[self.position]
+    
+    def str(self):
+        return f"x{self.position}"
+
+class StringConstant:
+    '''
+    Class to represent an string constant.
+    '''
+    def __init__(self, value):
+        self.value = value  # value of the constant
+        self.type = str     # type of the constant
+        self.weight = 1     # weight of the constant
+
+    def evaluate(self, input = None):
+        return self.value
+    
+    def str(self):
+        return str(self.value)
+
+class Concatenate:
+    '''
+    Operator to concatenate two string values.
+    '''
+    def __init__(self):
+        self.arity = 2                  # number of arguments
+        self.arg_types = [str, str]     # argument types
+        self.return_type = str          # return type
+        self.weight = 1                 # weight
+
+    def evaluate(self, x, y, input = None):
+        return x + y
+    
+    def str(self, x, y):
+        return f"Concat({x}, {y})"
+
+class Left:
+    '''
+    Operator to get left substring.
+    '''
+    def __init__(self):
+        self.arity = 2                  # number of arguments
+        self.arg_types = [str, int]     # argument types
+        self.return_type = str          # return type
+        self.weight = 1                 # weight
+
+    def evaluate(self, x, y, input = None):
+        return x[:y]
+    
+    def str(self, x, y):
+        return f"Left({x}, {y})"
+    
+class Right:
+    '''
+    Operator to get right substring.
+    '''
+    def __init__(self):
+        self.arity = 2                  # number of arguments
+        self.arg_types = [str, int]     # argument types
+        self.return_type = str          # return type
+        self.weight = 1                 # weight
+
+    def evaluate(self, x, y, input = None):
+        return x[(y * -1):]
+    
+    def str(self, x, y):
+        return f"Right({x}, {y})" 
+
+
+'''
+GLOBAL CONSTANTS
+''' 
+
+# define operators
+string_operators = [Concatenate(), Left(), Right()]

synthesis.py

@@ -15,6 +15,7 @@ import time
 
 # import examples
 from arithmetic import *
+from strings import *
 from abstract_syntax_tree import *
 from examples import example_set, check_examples
 import config
@@ -40,7 +41,7 @@ def parse_args():
                         choices=example_set.keys(),
                         help='Examples to synthesize program from. Must be a valid key in the "example_set" dictionary.')
     
-    parser.add_argument('--max_weight', type=int, required=False, default=3,
+    parser.add_argument('--max-weight', type=int, required=False, default=3,
                         help='Maximum weight of programs to consider before terminating search.')
 
     args = parser.parse_args()
@@ -74,7 +75,7 @@ def extract_constants(examples):
         if type(input) == int:
             constants.append(IntegerConstant(input))
         elif type(input) == str:
-            # constants.append(StringConstant(input))
+            constants.append(StringConstant(input))
             pass
         else:
             raise Exception("Input of unknown type.")
@@ -87,8 +88,7 @@ def extract_constants(examples):
         if arg == int:
             variables.append(IntegerVariable(position))
         elif arg == str:
-            # variables.append(StringVariable(position))
-            pass
+            variables.append(StringVariable(position))
         else:
             raise Exception("Input of unknown type.")
 
@@ -133,10 +133,16 @@ def run_synthesizer(args):
     # extract constants from examples
     program_bank = extract_constants(examples)
     program_bank_str = [p.str() for p in program_bank]
+    print("\nSynthesis Log:")
     print(f"- Extracted {len(program_bank)} constants from examples.")
 
     # define operators
-    operators = arithmetic_operators
+    if args.domain == "arithmetic":
+        operators = arithmetic_operators
+    elif args.domain == "string":
+        operators = string_operators
+    else:
+        raise Exception('Domain not recognized. Must be either "arithmetic" or "string".')
 
     # iterate over each level
     for weight in range(2, args.max_weight):
@@ -200,10 +206,11 @@ if __name__ == '__main__':
     elapsed_time = round(end_time - start_time, 4)
 
     # check if program was found
+    print("\nSynthesis Results:")
     if program is None:
-        print(f"Max weight of {args.max_weight} reached, no program found in {elapsed_time}s.")
+        print(f"- Max weight of {args.max_weight} reached, no program found in {elapsed_time}s.")
     else:
-        print(f"Program found in {elapsed_time}s.")
-        print(f"Program: {program.str()}")
-        print(f"Program weight: {program.weight}")
-        print(f"Program return type: {program.type.__name__}")
+        print(f"- Program found in {elapsed_time}s.")
+        print(f"- Program: {program.str()}")
+        print(f"- Program weight: {program.weight}")
+        print(f"- Program return type: {program.type.__name__}")