Extract constants and variables

README.md

@@ -2,7 +2,7 @@
 
 🚨🚨PLEASE DO NOT GRADE YET🚨🚨
 
-Completed for [CS252R: Program Synthesis](https://synthesis.metareflection.club/) at the Harvard John A. Paulson School of Engineering and Applied Sciences, taught Fall 2023 by Prof. Nada Amin.
+Completed for [CS252R: Program Synthesis](https://synthesis.metareflection.club/) at the Harvard John A. Paulson School of Engineering and Applied Sciences, taught in Fall 2023 by Prof. Nada Amin.
 
 ## 🛠️ Background
 
@@ -37,7 +37,7 @@ optional arguments:
   --domain {arithmetic,string}
                         Domain of synthesis (either "arithmetic" or "string").
   --examples {addition,subtraction,multiplication,division}
-                        Examples to synthesize program from. Must be a valid key in the "examples" dictionary.
+                        Examples to synthesize program from. Must be a valid key in the "example_set" dictionary.
   --max_weight MAX_WEIGHT
                         Maximum weight of programs to consider before terminating search.
 ```
@@ -47,7 +47,7 @@ For example, to synthesize programs in the arithmetic domain from the addition i
 python3 synthesizer.py --domain arithmetic --examples addition
 ```
 
-To add additional input-output examples, modify `examples.py`. Add a new key to the dictionary `examples`` and set the value to be a list of tuples.
+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.
 
 ## 🔮 Virtual Environment
 

abstract_syntax_trees.py

@@ -0,0 +1,5 @@
+'''
+ABSTRACT SYNTAX TREES
+This file contains Python classes that define the abstract syntax tree (AST) for program synthesis.
+'''
+

arithmetic.py

@@ -7,22 +7,36 @@ This file contains Python classes that define the arithmetic operators for progr
 CLASS DEFINITIONS
 ''' 
 
-class IntegerValue:
+class IntegerVariable:
     '''
-    Class to represent an arithmetic value.
+    Class to represent an integer variable. Note that position is the position of the variable in the input.
+    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, value):
+    def __init__(self, position):
+        self.value = None           # value of the variable, initially None
+        self.position = position    # position of the variable in the arguments to program
+        self.type = int             # type of the variable
+
+    def assign(self, value):
         self.value = value
-        self.type = int
+
+class IntegerConstant:
+    '''
+    Class to represent an integer constant.
+    '''
+    def __init__(self, value):
+        self.value = value  # value of the constant
+        self.type = int     # type of the constant
 
 class Add:
     '''
     Operator to add two numerical values.
     '''
     def __init__(self):
-        self.arity = 2          # number of arguments of function
-        self.weight = 1         # weight of function
-        self.return_type = int  # return type of function
+        self.arity = 2                  # number of arguments
+        self.arg_types = [int, int]     # argument types
+        self.return_type = int          # return type
+        self.weight = 1                 # weight
 
     def __call__(self, x, y):
         return x + y
@@ -35,9 +49,10 @@ class Subtract:
     Operator to subtract two numerical values.
     '''
     def __init__(self):
-        self.arity = 2          # number of arguments of function
-        self.weight = 1         # weight of function
-        self.return_type = int  # return type of function
+        self.arity = 2                  # number of arguments
+        self.arg_types = [int, int]     # argument types
+        self.return_type = int          # return type
+        self.weight = 1                 # weight
 
     def __call__(self, x, y):
         return x - y
@@ -50,9 +65,10 @@ class Multiply:
     Operator to multiply two numerical values.
     '''
     def __init__(self):
-        self.arity = 2          # number of arguments of function
-        self.weight = 1         # weight of function
-        self.return_type = int  # return type of function
+        self.arity = 2                  # number of arguments
+        self.arg_types = [int, int]     # argument types
+        self.return_type = int          # return type
+        self.weight = 1                 # weight
 
     def __call__(self, x, y):
         return x * y
@@ -65,9 +81,10 @@ class Divide:
     Operator to divide two numerical values.
     '''
     def __init__(self):
-        self.arity = 2          # number of arguments of function
-        self.weight = 1         # weight of function
-        self.return_type = int  # return type of function
+        self.arity = 2                  # number of arguments
+        self.arg_types = [int, int]     # argument types
+        self.return_type = int          # return type
+        self.weight = 1                 # weight
 
     def __call__(self, x, y):
         try: # check for division by zero error
@@ -79,11 +96,6 @@ class Divide:
         return f"{x} / {y}"
 
 
-'''
-FUNCTION DEFINITIONS
-''' 
-
-
 '''
 GLOBAL CONSTANTS
 ''' 

demonstration.ipynb

@@ -15,7 +15,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -27,7 +27,7 @@
     "\n",
     "# import arithmetic module\n",
     "# from arithmetic import *\n",
-    "from examples import examples\n",
+    "from examples import example_set, check_examples\n",
     "import config"
    ]
   },
@@ -40,16 +40,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "domain = \"arithmetic\"\n",
     "examples_key = \"addition\"\n",
-    "examples = examples[examples_key]\n",
+    "examples = example_set[examples_key]\n",
     "max_weight = 3"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First, I define a function to check that, across all input-output pairs, all inputs are of the same length and that argument types are consistent across inputs."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -59,35 +66,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
-    "'''\n",
-    "ARTHIMETIC OPERATORS\n",
-    "This file contains Python classes that define the arithmetic operators for program synthesis.\n",
-    "'''\n",
+    "class IntegerVariable:\n",
+    "    '''\n",
+    "    Class to represent an integer variable. Note that position is the position of the variable in the input.\n",
+    "    For example, if the input is [4, 5, 6] and the variable is the third element (i.e., 6), then position = 2.\n",
+    "    '''\n",
+    "    def __init__(self, position):\n",
+    "        self.value = None           # value of the variable, initially None\n",
+    "        self.position = position    # position of the variable in the arguments to program\n",
+    "        self.type = int             # type of the variable\n",
     "\n",
-    "'''\n",
-    "CLASS DEFINITIONS\n",
-    "''' \n",
+    "    def assign(self, value):\n",
+    "        self.value = value\n",
     "\n",
-    "class IntegerValue:\n",
+    "class IntegerConstant:\n",
     "    '''\n",
-    "    Class to represent an arithmetic value.\n",
+    "    Class to represent an integer constant.\n",
     "    '''\n",
     "    def __init__(self, value):\n",
-    "        self.value = value\n",
-    "        self.type = int\n",
+    "        self.value = value  # value of the constant\n",
+    "        self.type = int     # type of the constant\n",
     "\n",
     "class Add:\n",
     "    '''\n",
     "    Operator to add two numerical values.\n",
     "    '''\n",
     "    def __init__(self):\n",
-    "        self.arity = 2          # number of arguments of function\n",
-    "        self.weight = 1         # weight of function\n",
-    "        self.return_type = int  # return type of function\n",
+    "        self.arity = 2                  # number of arguments\n",
+    "        self.arg_types = [int, int]     # argument types\n",
+    "        self.return_type = int          # return type\n",
+    "        self.weight = 1                 # weight\n",
     "\n",
     "    def __call__(self, x, y):\n",
     "        return x + y\n",
@@ -100,9 +112,10 @@
     "    Operator to subtract two numerical values.\n",
     "    '''\n",
     "    def __init__(self):\n",
-    "        self.arity = 2          # number of arguments of function\n",
-    "        self.weight = 1         # weight of function\n",
-    "        self.return_type = int  # return type of function\n",
+    "        self.arity = 2                  # number of arguments\n",
+    "        self.arg_types = [int, int]     # argument types\n",
+    "        self.return_type = int          # return type\n",
+    "        self.weight = 1                 # weight\n",
     "\n",
     "    def __call__(self, x, y):\n",
     "        return x - y\n",
@@ -115,9 +128,10 @@
     "    Operator to multiply two numerical values.\n",
     "    '''\n",
     "    def __init__(self):\n",
-    "        self.arity = 2          # number of arguments of function\n",
-    "        self.weight = 1         # weight of function\n",
-    "        self.return_type = int  # return type of function\n",
+    "        self.arity = 2                  # number of arguments\n",
+    "        self.arg_types = [int, int]     # argument types\n",
+    "        self.return_type = int          # return type\n",
+    "        self.weight = 1                 # weight\n",
     "\n",
     "    def __call__(self, x, y):\n",
     "        return x * y\n",
@@ -130,9 +144,10 @@
     "    Operator to divide two numerical values.\n",
     "    '''\n",
     "    def __init__(self):\n",
-    "        self.arity = 2          # number of arguments of function\n",
-    "        self.weight = 1         # weight of function\n",
-    "        self.return_type = int  # return type of function\n",
+    "        self.arity = 2                  # number of arguments\n",
+    "        self.arg_types = [int, int]     # argument types\n",
+    "        self.return_type = int          # return type\n",
+    "        self.weight = 1                 # weight\n",
     "\n",
     "    def __call__(self, x, y):\n",
     "        try: # check for division by zero error\n",
@@ -145,11 +160,6 @@
     "\n",
     "\n",
     "'''\n",
-    "FUNCTION DEFINITIONS\n",
-    "''' \n",
-    "\n",
-    "\n",
-    "'''\n",
     "GLOBAL CONSTANTS\n",
     "''' \n",
     "\n",
@@ -161,7 +171,70 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "I define input-output examples."
+    "I define a function to extract constants from examples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def extract_constants(examples):\n",
+    "    '''\n",
+    "    Extracts the constants from the input-output examples. Also constructs variables as needed\n",
+    "    based on the input-output examples, and adds them to the list of constants.\n",
+    "    '''\n",
+    "\n",
+    "    # check validity of provided examples\n",
+    "    # if valid, extract arity and argument types\n",
+    "    arity, arg_types = check_examples(examples)\n",
+    "\n",
+    "    # initialize list of constants\n",
+    "    constants = []\n",
+    "\n",
+    "    # get unique set of inputs\n",
+    "    inputs = [input for example in examples for input in example[0]]\n",
+    "    inputs = set(inputs)\n",
+    "\n",
+    "    # add 1 to the set of inputs\n",
+    "    inputs.add(1)\n",
+    "\n",
+    "    # extract constants in input\n",
+    "    for input in inputs:\n",
+    "\n",
+    "        if type(input) == int:\n",
+    "            constants.append(IntegerConstant(input))\n",
+    "        elif type(input) == str:\n",
+    "            # constants.append(StringConstant(input))\n",
+    "            pass\n",
+    "        else:\n",
+    "            raise Exception(\"Input of unknown type.\")\n",
+    "        \n",
+    "    # initialize list of variables\n",
+    "    variables = []\n",
+    "\n",
+    "    # extract variables in input\n",
+    "    for position, arg in enumerate(arg_types):\n",
+    "        if arg == int:\n",
+    "            variables.append(IntegerVariable(position))\n",
+    "        elif arg == str:\n",
+    "            # variables.append(StringVariable(position))\n",
+    "            pass\n",
+    "        else:\n",
+    "            raise Exception(\"Input of unknown type.\")\n",
+    "\n",
+    "    return constants + variables"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize program bank\n",
+    "program_bank = extract_constants(examples)"
    ]
   },
   {
@@ -198,16 +271,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# initialize program bank\n",
-    "program_bank = []\n",
-    "\n",
     "# iterate over each level\n",
-    "for i in range(1, max_level):\n",
+    "for i in range(2, max_weight):\n",
     "\n",
     "    # define level program bank\n",
     "    level_program_bank = []\n",
     "\n",
-    "    for op in arithmetic_operators():\n",
+    "    for op in arithmetic_operators:\n",
     "\n",
     "        break"
    ]

examples.py

@@ -1,13 +1,18 @@
 '''
 EXAMPLES
 This file contains input-output examples for both arithmetic and string domain-specific languages (DSLs).
-To add a new example, add a new key to the dictionary 'examples' and set the value to be a list of tuples.
+To add a new example, add a new key to the dictionary 'example_set' and set the value to be a list of tuples.
+
+Note that we synthesize programs with a consistent arity. Therefore, in each set of input-output examples, all 
+input examples must be of the same length. Further, argument types must remain consistent across examples. We 
+test for these conditions in the `check_examples` function below, which is called by the `extract_constants` 
+function in the synthesizer.
 '''
 
 # define examples
-examples = {
+example_set = {
     # arithmetic examples
-    'addition': [([7, 2], 9), ([4, 6], 10), ([8, 1], 9), ([3, 9], 12), ([5, 8], 13)],
+    '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)]
@@ -15,4 +20,36 @@ examples = {
     # string examples
 
     # custom user examples
-}
+}
+
+
+# CHECK EXAMPLE VALIDITY
+def check_examples(examples):
+    '''
+    Checks that all input examples are of same length and that argument types are consistent across examples.
+    If valid, returns arity and argument types of function to be generated.
+
+    Args:
+        examples (list): list of tuples, where each tuple is of the form (input, output)
+    
+    Returns:
+        input_lengths[0] (int): arity of function
+        arg_types[0] (list): argument types of function
+    '''
+
+    # get input examples
+    inputs = [example[0] for example in examples]
+
+    # check all inputs are of same length
+    input_lengths = [len(input) for input in inputs]
+    if len(set(input_lengths)) != 1:
+        raise ValueError("All input examples must be of same length.")
+
+    # check that types of arguments are same
+    arg_types = [[type(arg) for arg in input] for input in inputs]
+    consistent_types = all([arg_types[0] == arg_type for arg_type in arg_types])
+    if not consistent_types:
+        raise ValueError("Argument types must be consistent across inputs.")
+    
+    # return arity and argument types
+    return input_lengths[0], arg_types[0]

synthesizer.py

@@ -12,11 +12,13 @@ import numpy as np
 import argparse
 
 # import examples
-from examples import examples
+from arithmetic import *
+from examples import example_set, check_examples
 import config
 
 
-def parse_args(examples):
+# PARSE ARGUMENTS
+def parse_args():
     '''
     Parse command line arguments.
     '''
@@ -32,8 +34,8 @@ def parse_args(examples):
                         help='Domain of synthesis (either "arithmetic" or "string").')
 
     parser.add_argument('--examples', dest='examples_key', type=str, required=True, # default="addition",
-                        choices=examples.keys(),
-                        help='Examples to synthesize program from. Must be a valid key in the "examples" dictionary.')
+                        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,
                         help='Maximum weight of programs to consider before terminating search.')
@@ -42,13 +44,75 @@ def parse_args(examples):
     return args
 
 
+# EXTRACT CONSTANTS AND VARIABLES
+def extract_constants(examples):
+    '''
+    Extracts the constants from the input-output examples. Also constructs variables as needed
+    based on the input-output examples, and adds them to the list of constants.
+    '''
+
+    # check validity of provided examples
+    # if valid, extract arity and argument types
+    arity, arg_types = check_examples(examples)
+
+    # initialize list of constants
+    constants = []
+
+    # get unique set of inputs
+    inputs = [input for example in examples for input in example[0]]
+    inputs = set(inputs)
+
+    # add 1 to the set of inputs
+    inputs.add(1)
+
+    # extract constants in input
+    for input in inputs:
+
+        if type(input) == int:
+            constants.append(IntegerConstant(input))
+        elif type(input) == str:
+            # constants.append(StringConstant(input))
+            pass
+        else:
+            raise Exception("Input of unknown type.")
+        
+    # initialize list of variables
+    variables = []
+
+    # extract variables in input
+    for position, arg in enumerate(arg_types):
+        if arg == int:
+            variables.append(IntegerVariable(position))
+        elif arg == str:
+            # variables.append(StringVariable(position))
+            pass
+        else:
+            raise Exception("Input of unknown type.")
+
+    return constants + variables
+
+
+# RUN SYNTHESIZER
+def run_synthesizer(args):
+    '''
+    Run bottom-up enumerative synthesis.
+    '''
+
+    # retrieve selected input-output examples
+    examples = example_set[args.examples_key]
+
+    # extract constants from examples
+    program_bank = extract_constants(examples)
+    print(examples)
+
+    pass
+
+
 if __name__ == '__main__':
 
     # parse command line arguments
-    args = parse_args(examples)
-    print(args.domain)
-    print(args.examples_key)
-    print(args.max_weight)
+    args = parse_args()
+    # print(args)
 
     # run bottom-up enumerative synthesis
-    # run_synthesizer(args)
+    run_synthesizer(args)