Add demonstration

README.md

@@ -92,7 +92,7 @@ Synthesis Results:
 
 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.
 
-## 🔎 Algorithmic Description
+## 🔎 Algorithm Details
 
 The most important data structure in this implementation is the abstract syntax tree (AST). The AST is a tree representation of a program, where each node is either a primitive or a compound expression. The AST is represented by the `OperatorNode` class in `abstract_syntax_tree.py`. My AST implementation includes functions to recursively evaluate the operator and its operands and also to generate a string representation of the program.
 

app.py

@@ -17,11 +17,6 @@ import config
 # write streamlit title
 st.title("Bottom-Up Program Synthesis")
 
-# create class to hold arguments instead of arg-parser
-class Args(object):
-    pass
-args = Args()
-
 st.markdown('''
 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.
 ''')
@@ -32,7 +27,97 @@ st.markdown('''
 Here, we implement the non-ML subset of BUSTLE, the algorithm proposed by [Odena *et al.* (2021)](https://arxiv.org/abs/2007.14381). That is, we implement bottom-up enumerative search for simple compound expressions, excluding conditionals, recursion, and loops. The implementation is generic and flexibly supports multiple target languages. Arithmetic and string manipulations are natively supported, defined in `arithmetic.py` and `string.py`, respectively.
 ''')
 
-st.header("🔎 Algorithmic Description")
+st.subheader("Input-Output Examples")
+
+st.markdown('''
+Select input-output examples as defined in `examples.py`, or define your own custom examples. The examples are used to synthesize a program that satisfies the examples.
+''')
+
+# define variables
+domain = "arithmetic"
+examples_key = "addition"
+max_weight = 3
+
+# retrieve selected input-output examples
+examples = example_set[examples_key]
+
+# 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
+if domain == "arithmetic":
+    operators = arithmetic_operators
+elif domain == "strings":
+    operators = string_operators
+else:
+    raise Exception('Domain not recognized. Must be either "arithmetic" or "string".')
+
+# define final program
+final_program = None
+
+start_time = time.time()
+# iterate over each level
+for weight in range(2, max_weight):
+
+    # print message
+    print(f"- Searching level {weight} with {len(program_bank)} primitives.")
+
+    # iterate over each operator
+    for op in operators:
+
+        # get all possible combinations of primitives in program bank
+        combinations = itertools.combinations(program_bank, op.arity)
+
+        # iterate over each combination
+        for combination in combinations:
+
+            # get type signature
+            type_signature = [p.type for p in combination]
+
+            # check if type signature matches operator
+            if type_signature != op.arg_types:
+                continue
+
+            # check that sum of weights of arguments <= w
+            if sum([p.weight for p in combination]) > weight:
+                continue
+
+            # create new program
+            program = OperatorNode(op, combination)
+
+            # check if program is in program bank using string representation
+            if program.str() in program_bank_str:
+                continue
+            
+            # check if program is observationally equivalent to any program in program bank
+            if any([observationally_equivalent(program, p, examples) for p in program_bank]):
+                continue
+
+            # add program to program bank
+            program_bank.append(program)
+            program_bank_str.append(program.str())
+
+            # check if program passes all examples
+            if check_program(program, examples):
+                final_program = program
+
+end_time = time.time()
+elapsed_time = round(end_time - start_time, 4)
+
+# check if program was found
+print("\nSynthesis Results:")
+if final_program is None:
+    print(f"- Max weight of {max_weight} reached, no program found in {elapsed_time}s.")
+else:
+    print(f"- Program found in {elapsed_time}s.")
+    print(f"- Program: {final_program.str()}")
+    print(f"- Program weight: {final_program.weight}")
+    print(f"- Program return type: {final_program.type.__name__}")
+
+st.header("🔎 Algorithm Details")
 
 st.markdown('''
 The most important data structure in this implementation is the abstract syntax tree (AST). The AST is a tree representation of a program, where each node is either a primitive or a compound expression. The AST is represented by the `OperatorNode` class in `abstract_syntax_tree.py`. My AST implementation includes functions to recursively evaluate the operator and its operands and also to generate a string representation of the program.
@@ -40,7 +125,7 @@ The most important data structure in this implementation is the abstract syntax
 At program evaluation time, the AST is evaluated from the bottom up. That is, the operands are evaluated first, and then the operator is evaluated on the operands. This is implemented in the `evaluate` method of the `OperatorNode` class. In the case of integers, variable inputs are represented by the `IntegerVariable` class in `arithmetic.py`. When input is not `None`, input type checking and validation is performed by the `evaluate` function in this class.
 
 The pseudocode for the bottom-up synthesis algorithm is reproduced below from [Odena *et al.* (2021)](https://arxiv.org/abs/2007.14381):
-'''
+''')
 
 st.image("https://github.com/ayushnoori/program-synthesis/assets/43010710/117e7797-11af-4b72-b5f4-dda95eb2260f")