Add examples and argument parsing.

Code/arithmetic.py

@@ -0,0 +1,92 @@
+'''
+ARTHIMETIC OPERATORS
+This file contains Python classes that define the arithmetic operators for program synthesis.
+'''
+
+'''
+CLASS DEFINITIONS
+''' 
+
+class IntegerValue:
+    '''
+    Class to represent an arithmetic value.
+    '''
+    def __init__(self, value):
+        self.value = value
+        self.type = int
+
+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
+
+    def __call__(self, x, y):
+        return x + y
+    
+    def str(x, y):
+        return f"{x} + {y}"
+
+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
+
+    def __call__(self, x, y):
+        return x - y
+    
+    def str(x, y):
+        return f"{x} - {y}"
+    
+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
+
+    def __call__(self, x, y):
+        return x * y
+    
+    def str(x, y):
+        return f"{x} * {y}" 
+
+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
+
+    def __call__(self, x, y):
+        try: # check for division by zero error
+            return x / y
+        except ZeroDivisionError:
+            return None
+    
+    def str(x, y):
+        return f"{x} / {y}"
+
+
+'''
+FUNCTION DEFINITIONS
+''' 
+
+
+'''
+GLOBAL CONSTANTS
+''' 
+
+# define operators
+arithmetic_operators = [Add(), Subtract(), Multiply(), Divide()]

Code/demonstration.ipynb

@@ -0,0 +1,241 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# PSET 1: Bottom-Up Synthesis\n",
+    "\n",
+    "I follow Algorithm 1 in the BUSTLE paper:\n",
+    "\n",
+    "> Odena, A. *et al.* BUSTLE: Bottom-Up Program Synthesis Through Learning-Guided Exploration. in *9th International Conference on Learning Representations*; 2021 May 3-7; Austria.\n",
+    "\n",
+    "First, I import the required libraries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import itertools\n",
+    "\n",
+    "# argument parser for command line arguments\n",
+    "import argparse\n",
+    "\n",
+    "# import arithmetic module\n",
+    "# from arithmetic import *\n",
+    "from examples import examples\n",
+    "\n",
+    "# import project config file\n",
+    "import sys\n",
+    "sys.path.append('..')\n",
+    "import project_config"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First, I define variables as proxies for command-line arguments provided to the synthesizer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "domain = \"arithmetic\"\n",
+    "examples_key = \"addition\"\n",
+    "examples = examples[examples_key]\n",
+    "max_level = 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "I provide examples of arithmetic operations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "'''\n",
+    "ARTHIMETIC OPERATORS\n",
+    "This file contains Python classes that define the arithmetic operators for program synthesis.\n",
+    "'''\n",
+    "\n",
+    "'''\n",
+    "CLASS DEFINITIONS\n",
+    "''' \n",
+    "\n",
+    "class IntegerValue:\n",
+    "    '''\n",
+    "    Class to represent an arithmetic value.\n",
+    "    '''\n",
+    "    def __init__(self, value):\n",
+    "        self.value = value\n",
+    "        self.type = int\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",
+    "\n",
+    "    def __call__(self, x, y):\n",
+    "        return x + y\n",
+    "    \n",
+    "    def str(x, y):\n",
+    "        return f\"{x} + {y}\"\n",
+    "\n",
+    "class Subtract:\n",
+    "    '''\n",
+    "    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",
+    "\n",
+    "    def __call__(self, x, y):\n",
+    "        return x - y\n",
+    "    \n",
+    "    def str(x, y):\n",
+    "        return f\"{x} - {y}\"\n",
+    "    \n",
+    "class Multiply:\n",
+    "    '''\n",
+    "    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",
+    "\n",
+    "    def __call__(self, x, y):\n",
+    "        return x * y\n",
+    "    \n",
+    "    def str(x, y):\n",
+    "        return f\"{x} * {y}\" \n",
+    "\n",
+    "class Divide:\n",
+    "    '''\n",
+    "    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",
+    "\n",
+    "    def __call__(self, x, y):\n",
+    "        try: # check for division by zero error\n",
+    "            return x / y\n",
+    "        except ZeroDivisionError:\n",
+    "            return None\n",
+    "    \n",
+    "    def str(x, y):\n",
+    "        return f\"{x} / {y}\"\n",
+    "\n",
+    "\n",
+    "'''\n",
+    "FUNCTION DEFINITIONS\n",
+    "''' \n",
+    "\n",
+    "\n",
+    "'''\n",
+    "GLOBAL CONSTANTS\n",
+    "''' \n",
+    "\n",
+    "# define operators\n",
+    "arithmetic_operators = [Add(), Subtract(), Multiply(), Divide()]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "I define input-output examples."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "I define a function to determine observational equivalence."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def observationally_equivalent(a, b):\n",
+    "    \"\"\"\n",
+    "    Returns True if a and b are observationally equivalent, False otherwise.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, I define the bottom-up synthesis algorithm."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize program bank\n",
+    "program_bank = []\n",
+    "\n",
+    "# iterate over each level\n",
+    "for i in range(1, max_level):\n",
+    "\n",
+    "    # define level program bank\n",
+    "    level_program_bank = []\n",
+    "\n",
+    "    for op in arithmetic_operators():\n",
+    "\n",
+    "        break"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Code/examples.py

@@ -0,0 +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.
+'''
+
+# define examples
+examples = {
+    # arithmetic examples
+    'addition': [([7, 2], 9), ([4, 6], 10), ([8, 1], 9), ([3, 9], 12), ([5, 8], 13)],
+    '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)]
+
+    # string examples
+
+    # custom user examples
+}

Code/synthesizer.py

@@ -2,14 +2,56 @@
 BOTTOM UP ENUMERATIVE SYNTHESIS
 Ayush Noori
 CS252R, Fall 2020
+
+Example of usage:
+python synthesizer.py --domain arithmetic --examples addition
 '''
 
 # load libraries
 import numpy as np
-import os
+import argparse
+
+# import examples
+from examples import examples
 
 # import project config file
 import sys
 sys.path.append('..')
 import project_config
 
+
+def parse_args(examples):
+    '''
+    Parse command line arguments.
+    '''
+
+    parser = argparse.ArgumentParser(description="Bottom-up enumerative synthesis in Python.")
+
+    # define valid choices for the 'domain' argument
+    valid_domain_choices = ["arithmetic", "string"]
+
+    # add examples
+    parser.add_argument('--domain', type=str, required=True, # default="arithmetic",
+                        choices=valid_domain_choices,
+                        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.')
+    
+    parser.add_argument('--max_levels', type=int, required=False, default=3)
+
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == '__main__':
+
+    # parse command line arguments
+    args = parse_args(examples)
+    print(args.domain)
+    print(args.examples_key)
+    print(args.max_levels)
+
+    # run bottom-up enumerative synthesis
+    # run_synthesizer(args)

README.md

@@ -1,8 +1,10 @@
-# Bottom-Up Enumerative Synthesis
+# Bottom-Up Enumerative Program Synthesis
+
+🚨🚨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.
 
-## 🛠️ Inductive Program Synthesis
+## 🛠️ Inductive Synthesis
 
 The following notes are adapted from [*Introduction to Program Synthesis*](http://people.csail.mit.edu/asolar/SynthesisCourse/TOC.htm) by Armando Solar-Lezama.
 
@@ -21,9 +23,12 @@ Synthesize(inputs, outputs):
 
 ## 👨🏽‍💻 Project Description
 
-Here, we implement the non-ML subset of BUSTLE, the algorithm proposed by Odena *et al.* (2021). 
+Here, we implement the non-ML subset of BUSTLE, the algorithm proposed by Odena *et al.* (2021). That is, we implement bottom-up enumerative search for simple compound expressions, excluding conditionals, recursion and loops.
 
-## 📖 References
+## 🙏🏽 Acknowledgements
 
-1. Odena, A. *et al.* BUSTLE: Bottom-Up Program Synthesis Through Learning-Guided Exploration. in *9th International Conference on Learning Representations*; 2021 May 3-7; Austria.
+I thank [Tyler Holloway](mailto:tylerholloway@g.harvard.edu), teaching fellow in CS252R, for her guidance in completing this implementation of bottom-up enumerative program synthesis.
+
+## 📖 References
 
+1. Odena, A. *et al.* BUSTLE: Bottom-Up Program Synthesis Through Learning-Guided Exploration. in *9th International Conference on Learning Representations*; 2021 May 3-7; Austria.