added a synthesizer on top

abstract_syntax_tree.py

@@ -0,0 +1,72 @@
+'''
+ABSTRACT SYNTAX TREE
+This file contains the Python class that represents programs created by our rasp synthesizer.
+'''
+from utils import *
+
+class OperatorNode:
+    '''
+    Class to represent operator nodes (i.e., an operator and its operands) as an AST.
+
+    Args:
+        operator (object): operator object (e.g., Select, Aggregate, etc.)
+        children (list): list of children nodes (operands)
+    
+    Example:
+        select_node: OperatorNode(Select(), [Tokens(), Tokens(), Equal()])
+        select_node.str() = "select(tokens, tokens, ==)"
+        select_node.evaluate("hi") = [[1, 0], [0, 1]]
+        select_node.to_python() = rasp.Select(rasp.tokens, rasp.tokens, rasp.Comparison.EQ)
+    '''
+    def __init__(self, operator, children):
+        self.operator = operator
+        self.children = children
+        self.weight = operator.weight + sum([child.weight for child in children])
+        self.return_type = operator.return_type
+    
+    def str(self):
+        if len(self.children) != self.operator.n_args:
+            raise ValueError("Improper number of arguments for operator.")
+        operand_strings = [child.str() for child in self.children]
+        return f"({self.operator.str(*operand_strings)})" 
+        
+    def evaluate(self, input=None):
+        '''
+        Directly evaluate the python translation.
+        '''
+        exe = self.to_python()
+        return exe(input)
+
+        # DEPRECATED VERSION: uses the actual rasp repl
+        # exe = f"({self.str()})" + f"({repr(input)});".replace("'", "\"")
+        # return run_repl(exe)
+        
+    def to_python(self):
+        if len(self.children) != self.operator.n_args:
+            raise ValueError("Improper number of arguments for operator.")  
+        operands = [child.to_python() for child in self.children]
+        return self.operator.to_python(*operands)
+    
+'''
+TESTING
+'''
+if __name__ == "__main__":
+    from python_embedded_rasp import *
+    from tracr.rasp import rasp
+    
+    select_op = OperatorNode(Select(), [Tokens(), Tokens(), Equal()]) # wait should children be operators or operator nodes? maybe can be either?
+    assert (select_op.weight == 4)
+    
+    select_op_str = select_op.str()
+    actual_so_str = "(select(tokens, tokens, ==))"
+    assert select_op_str == actual_so_str
+    
+    select_op_res = select_op.evaluate("hi")
+    actual_so_res = [[1, 0],[0, 1]]
+    assert select_op_res == actual_so_res 
+    
+    select_op_python = select_op.to_python()
+    actual_so_python = rasp.Select(rasp.tokens, rasp.tokens, rasp.Comparison.EQ)
+    assert type(select_op_python) == type(actual_so_python)
+    
+    print("all tests passed hooray!")

app.py

@@ -0,0 +1,18 @@
+'''
+For future reference with downloading model files:
+
+import streamlit as st
+import pickle
+import base64
+
+x = {"my": "data"}
+
+def download_model(model):
+    output_model = pickle.dumps(model)
+    b64 = base64.b64encode(output_model).decode()
+    href = f'<a href="data:file/output_model;base64,{b64}" download="myfile.pkl">Download Trained Model .pkl File</a>'
+    st.markdown(href, unsafe_allow_html=True)
+
+
+download_model(x)
+'''

outtest.txt

@@ -0,0 +1,36 @@
+Received the following input and output examples:
+[(['h', 'e', 'l', 'l', 'o'], [1, 1, 2, 2, 1])]
+Running synthesizer with
+Vocab: {'o', 'e', 'h', 'l'}
+Max sequence length: 5
+Max weight: 25
+(indices - indices)
+[[0, 0, 0, 0, 0]]
+(indices - 0)
+[[0, 1, 2, 3, 4]]
+(indices - 1)
+[[-1, 0, 1, 2, 3]]
+(0 - indices)
+[[0, -1, -2, -3, -4]]
+(1 - indices)
+[[1, 0, -1, -2, -3]]
+(select(tokens, tokens, ==))
+[[[True, False, False, False, False], [False, True, False, False, False], [False, False, True, True, False], [False, False, True, True, False], [False, False, False, False, True]]]
+(select(tokens, tokens, true))
+[[[True, True, True, True, True], [True, True, True, True, True], [True, True, True, True, True], [True, True, True, True, True], [True, True, True, True, True]]]
+(select(tokens, indices, ==))
+[[[False, False, False, False, False], [False, False, False, False, False], [False, False, False, False, False], [False, False, False, False, False], [False, False, False, False, False]]]
+(select(tokens, indices, true))
+[[[True, True, True, True, True], [True, True, True, True, True], [True, True, True, True, True], [True, True, True, True, True], [True, True, True, True, True]]]
+(select(indices, tokens, ==))
+[[[False, False, False, False, False], [False, False, False, False, False], [False, False, False, False, False], [False, False, False, False, False], [False, False, False, False, False]]]
+(select(indices, tokens, true))
+[[[True, True, True, True, True], [True, True, True, True, True], [True, True, True, True, True], [True, True, True, True, True], [True, True, True, True, True]]]
+(select(indices, indices, ==))
+[[[True, False, False, False, False], [False, True, False, False, False], [False, False, True, False, False], [False, False, False, True, False], [False, False, False, False, True]]]
+(select(indices, indices, true))
+[[[True, True, True, True, True], [True, True, True, True, True], [True, True, True, True, True], [True, True, True, True, True], [True, True, True, True, True]]]
+(select_width((select(tokens, tokens, ==))))
+[[1, 1, 2, 2, 1]]
+The following program has been compiled to a transformer with 1 layer(s):
+(select_width((select(tokens, tokens, ==))))

python_embedded_rasp.py

@@ -0,0 +1,308 @@
+'''
+RASP OPERATORS THAT ARE SUPPORTED BY TRACR'S PYTHON EMBEDDING
+This file contains Python classes that define the rasp operators supported by TRACR's python embedding of the langauge.
+This is subset of everything that TRACR supports in python, due to project time constraints.
+'''
+import random
+from typing import (Any, Callable, Dict, Generic, List, Mapping, Optional,
+                    Sequence, TypeVar, Union)
+from tracr.rasp import rasp
+import subprocess
+import time
+
+'''
+CLASS DEFINITIONS
+'''
+class Tokens:
+    '''
+    Tokens constant.
+    '''
+    def __init__(self):
+        self.n_args = 0
+        self.arg_types = []
+        self.return_type = rasp.SOp
+        self.weight = 1
+    
+    def to_python(self):
+        # return an object that can be compiled into a TRACR transformer
+        # arguments should be python objects
+        return rasp.tokens
+    
+    def str(self):
+        # represent rasp operator in string form
+        # expects arguments to be strings
+        return "tokens"
+    
+class Indices:
+    def __init__(self):
+        self.n_args = 0
+        self.arg_types = []
+        self.return_type = rasp.SOp
+        self.weight = 1
+    
+    def to_python(self):
+        # return an object that can be compiled into a TRACR transformer
+        # arguments should be python objects
+        return rasp.indices
+    
+    def str(self):
+        # represent rasp operator in string form
+        # expects arguments to be strings
+        return "indices"
+
+class Zero:
+    def __init__(self):
+        self.n_args = 0
+        self.arg_types = []
+        self.return_type = int
+        self.weight = 1
+    
+    def to_python(self):
+        # return an object that can be compiled into a TRACR transformer
+        # arguments should be python objects
+        return 0
+    
+    def str(self):
+        # represent rasp operator in string form
+        # expects arguments to be strings
+        return "0"
+
+class One:
+    def __init__(self):
+        self.n_args = 0
+        self.arg_types = []
+        self.return_type = int
+        self.weight = 1
+    
+    def to_python(self):
+        # return an object that can be compiled into a TRACR transformer
+        # arguments should be python objects
+        return 1
+    
+    def str(self):
+        # represent rasp operator in string form
+        # expects arguments to be strings
+        return "1"
+
+class Equal:
+    '''
+    Comparison Equal constant.
+    '''
+    def __init__(self):
+        self.n_args = 0
+        self.arg_types = []
+        self.return_type = rasp.Predicate
+        self.weight = 1
+    
+    def to_python(self):
+        # return an object that can be compiled into a TRACR transformer
+        # arguments should be python objects
+        return rasp.Comparison.EQ
+    
+    def str(self):
+        # represent rasp operator in string form
+        # expects arguments to be strings
+        return "=="
+
+class GT:
+    '''
+    Greater Than comparison operator.
+    '''
+    pass
+
+class LT:
+    '''
+    Less Than comparison operator
+    '''
+    pass
+
+class LEQ:
+    pass
+
+class GEQ:
+    pass
+
+class TRUE:
+    '''
+    Comparison True constant.
+    '''
+    def __init__(self):
+        self.n_args = 0
+        self.arg_types = []
+        self.return_type = rasp.Predicate
+        self.weight = 1
+    
+    def to_python(self):
+        # return an object that can be compiled into a TRACR transformer
+        # arguments should be python objects
+        return rasp.Comparison.TRUE
+    
+    def str(self):
+        # represent rasp operator in string form
+        # expects arguments to be strings
+        return "true"
+
+class FALSE:
+    pass
+
+class Add:
+    '''
+    Element-wise.
+    Input can be either int, float or s-op.
+    '''
+    pass
+
+class Subtract:
+    '''
+    Element-wise.
+    Input can be either int, float or s-op.
+    '''
+    def __init__(self):
+        self.n_args = 2
+        self.arg_types = [Union[rasp.SOp, float, int], Union[rasp.SOp, float, int]]
+        self.return_type = Union[rasp.SOp, int, float]
+        self.weight = 1
+    
+    def to_python(self, x, y):
+        # return an object that can be compiled into a TRACR transformer
+        # arguments should be python objects
+        if type(x) == type(rasp.tokens):
+            return None
+        if type(y) == type(rasp.tokens):
+            return None
+        return x - y
+    
+    def str(self, x, y):
+        # represent rasp operator in string form
+        # expects arguments to be strings
+        return f"{x} - {y}"
+
+class Mult:
+    '''
+    Element-wise.
+    Input can be either int, float or s-op.
+    '''
+    pass
+
+class Divide:
+    '''
+    Element-wise.
+    Input can be either int, float or s-op.
+    '''
+    pass
+
+class Fill:
+    '''
+    Given fill value and length, returns Sop of that length with that fill value.
+    Fill value can be int, float, or char.
+    Length must be a positive integer.
+    '''
+    pass
+
+class SelectorAnd:
+    '''
+    Input can be bool or s-op.
+    '''
+    pass
+
+class SelectorOr:
+    '''
+    Input can be bool or s-op.
+    '''
+    pass
+
+class SelectorNot:
+    '''
+    Input is an s-op of bools. (Or bool-convertible values.)
+    '''
+    pass
+
+class Select:
+    '''
+    Select operator.
+    '''
+    def __init__(self):
+        self.n_args = 3
+        self.arg_types = [rasp.SOp, rasp.SOp, rasp.Predicate]
+        self.return_type = rasp.Selector 
+        self.weight = 1
+    
+    def to_python(self, sop1, sop2, comp):
+        # return an object that can be compiled into a TRACR transformer
+        # arguments should be python objects
+        return rasp.Select(sop1, sop2, comp)
+    
+    def str(self, sop1, sop2, comp):
+        # represent rasp operator in string form
+        # expects arguments to be strings
+        return f"select({sop1}, {sop2}, {comp})"
+
+class Aggregate:
+    '''
+    The Aggregate operator.
+    '''
+    def __init__(self):
+        self.n_args = 2
+        self.arg_types = [rasp.Selector, rasp.SOp]
+        self.return_type = rasp.SOp
+        self.weight = 1
+    
+    def to_python(self, sel, sop):
+        # return an object that can be compiled into a TRACR transformer
+        # arguments should be python objects
+        return rasp.Aggregate(sel, sop)
+    
+    def str(self, sel, sop):
+        # represent rasp operator in string form
+        # expects arguments to be strings
+        return f"aggregate({sel}, {sop})"
+
+class SelectorWidth:
+    '''
+    The selector_width operator.
+    '''
+    def __init__(self):
+        self.n_args = 1
+        self.arg_types = [rasp.Selector]
+        self.return_type = rasp.SOp 
+        self.weight = 1
+    
+    def to_python(self, sel):
+        # return an object that can be compiled into a TRACR transformer
+        # arguments should be python objects
+        return rasp.SelectorWidth(sel)
+    
+    def str(self, sel):
+        # represent rasp operator in string form
+        # expects arguments to be strings
+        return f"select_width({sel})"
+
+'''
+GLOBAL CONSTANTS
+'''
+
+# define operators
+rasp_operators = [Select(), SelectorWidth(), Aggregate(), Subtract()]
+rasp_consts = [Tokens(), Tokens(), Equal(), TRUE(), Indices(), Indices(), Zero(), One()]
+'''
+TESTING
+'''
+if __name__ == "__main__":
+    test_select = Select()
+    
+    test_select_python = test_select.to_python(Tokens().to_python(), Tokens().to_python(), Equal().to_python())
+    actual_ts_python = rasp.Select(rasp.tokens, rasp.tokens, rasp.Comparison.EQ)
+    assert type(Tokens().to_python()) == type(rasp.tokens)
+    assert type(Equal().to_python() == type(rasp.Comparison.EQ))
+    assert type(test_select_python) == type(actual_ts_python)
+    
+    test_select_string = test_select.str(Tokens().str(), Tokens().str(), Equal().str())
+    actual_ts_string = "select(tokens, tokens, ==)"
+    assert(test_select_string == actual_ts_string)
+    
+    
+    test_aggregate = Aggregate()
+    print(rasp.Aggregate(rasp.Select(rasp.tokens, rasp.tokens, rasp.Comparison.EQ), rasp.tokens)("hi"))
+    
+    print("all tests passed hooray!")
+    

rasp_synthesizer.py

@@ -0,0 +1,257 @@
+'''
+BOTTOM-UP ENUMERATIVE SYTHESIS FOR RASP
+
+Usage:
+python rasp_synthesis.py --examples
+'''
+import numpy as np
+import argparse
+import itertools
+import time
+import ast
+import re
+from tracr.compiler import compiling
+from typing import get_args
+import inspect
+
+from abstract_syntax_tree import *
+from python_embedded_rasp import *
+
+# PARSE ARGUMENTS
+def parse_args():
+    '''
+    Parse command line arguments.
+    '''
+    parser = argparse.ArgumentParser(description="Bottom-up enumerative synthesis for RASP.")
+    parser.add_argument('--examples', required=True, help="input/output sequence examples for synthesis")
+    parser.add_argument('--max_weight', type=int, required=False, default=10, help="Maximum weight of programs to consider before terminating search.")
+    args = parser.parse_args()
+    return args
+
+# ANALYZE EXAMPLES
+def analyze_examples(inputs):
+    '''
+    Returns a list of unique (input_sequence, output_sequence) tuples of proper python types.
+        Ensures each example is only numeric values or only char values.
+    Returns useful constants given the input examples. 
+    '''
+    example_ins = []
+    example_outs = []
+    try:
+        # Safely evaluate the string to a Python object
+        examples_lst = ast.literal_eval(inputs)
+    except (SyntaxError, ValueError) as e:
+        raise argparse.ArgumentTypeError(f"Invalid examples format: {e}")
+    
+    if not isinstance(examples_lst, list):
+        raise ValueError("Input should be a list.")
+    for ex in examples_lst:
+        try:
+            ins, outs = ex[0], ex[1]
+        except:
+            raise argparse.ArgumentTypeError(f"Invalid examples format.")
+        
+        def same_legal_type(lst):
+            return (all(isinstance(x, int) for x in lst) or
+                    all(isinstance(x, float) for x in lst) or
+                    all(isinstance(x, bool) for x in lst) or
+                    all(isinstance(x, str) for x in lst))
+        
+        if same_legal_type(ins) and same_legal_type(outs):
+            example_ins.append(ins)
+            example_outs.append(outs)
+            continue
+        raise argparse.ArgumentTypeError(f"Each example must have consistent types. Expected inputs to have type {first_in_type} and outputs to have {first_out_type} but instead inputs have types {[type(x) for x in ins]} and outputs have types {[type(x) for x in outs]}")
+    
+    return example_ins, example_outs
+    
+# GET VOCABULARY
+def get_vocabulary(examples):
+    '''
+    Returns vocabulary for later compiling the RASP model.
+    ''' 
+    vocab = []  
+    for ex in examples:
+        ins, outs = ex[0], ex[1]
+        vocab.extend([obj for obj in ins])
+    return set(vocab)
+    
+# CHECK OBSERVATIONAL EQUIVALENCE
+def check_obs_equivalence(examples, program_a, program_b):
+    try:
+        inputs = [example[0] for example in examples]
+        a_output = None
+        b_output = None
+        if program_a not in rasp_consts:
+            a_output = [program_a.evaluate(input) for input in inputs]
+        if program_b not in rasp_consts:
+            b_output = [program_b.evaluate(input) for input in inputs]
+    except:
+        return True # force the synthesizer to not consider this program
+
+    return a_output == b_output
+
+# CHECK CORRECTNESS
+def check_correctness(examples, program):
+    '''
+    Checks if the programs output matches expected output on all examples.
+    '''
+    try:
+        inputs = [example[0] for example in examples]
+        outputs = [example[1] for example in examples]
+        program_output = [program.evaluate(input) for input in inputs]
+    except:
+        return False
+    
+    print(program.str())
+    print(program_output)
+    
+    # TODO return number that match and return this
+    
+    return program_output == outputs
+
+# COMPARE TYPE SIGNATURES
+def compare_types(list1, list2):
+    for idx, type1 in enumerate(list1):
+        if idx >= len(list2):
+            return False  # The first list is longer than the second list
+
+        type2 = list2[idx]
+
+        # Check if type2 is a Union
+        if hasattr(type2, '__origin__') and type2.__origin__ is Union:
+            # Extract types from Union
+            types_in_union2 = get_args(type2)
+            # Check if type1 is a Union
+            if hasattr(type1, '__origin__') and type1.__origin__ is Union:
+                types_in_union1 = get_args(type1)
+                # Check if all types in type1's Union are in type2's Union
+                if not all(any(t1 == t2 for t2 in types_in_union2) for t1 in types_in_union1):
+                    return False
+            else:
+                # Check if type1 is in type2's Union
+                if not any(type1 == t2 for t2 in types_in_union2):
+                    return False
+        else:
+            # Direct type comparison
+            if type1 != type2:
+                return False
+
+    return True
+
+# RUN SYNTHESIZER
+def run_synthesizer(examples, max_weight):
+    '''
+    Run bottom-up enumerative synthesis.
+    '''
+    program_bank = rasp_consts
+    program_bank_str = [p.str() for p in program_bank]
+    
+    # TODO: store approximate programs, measured by number of output examples that match
+    
+    # iterate over each level
+    for weight in range(2, max_weight):
+        
+        for op in rasp_operators:
+            combinations = itertools.permutations(program_bank, op.n_args)
+            
+            for combination in combinations:
+                
+                type_signature = [p.return_type for p in combination]
+                
+                if not compare_types(type_signature, op.arg_types):
+                    continue
+    
+                if sum([p.weight for p in combination]) > weight:
+                    continue
+                
+                program = OperatorNode(op, combination)
+                
+                if program.str() in program_bank_str:
+                    continue
+                
+                if any([check_obs_equivalence(examples, program, p) for p in program_bank]):
+                    continue
+                
+                program_bank.append(program)
+                program_bank_str.append(program.str())
+                
+                if check_correctness(examples, program):
+                    return(program)  
+ 
+    return None
+
+# COMPILE RASP MODEL
+if __name__ == "__main__":
+    
+    '''
+    Some examples:
+    Identify anagrams:
+    [[['V','I','W',',','W','I','V'], [True, True, True, True, True, True, True]],[['a','b',',','b','a'], [True, True, True, True, True]],[['e','l',',','s','t'], [False, False, False, False, False]]]
+        Output: times out
+    Calculate the median of a list of numbers:
+    [[[1,2,3,4,5], [3,3,3,3,3]], [[2,8,10,11], [9,9,9,9]], [[1,2,3],[2,2,2]]]
+        Output: times out
+    Identity function:
+    [[['h','i'], ['h','i']]]
+        Output: (aggregate((select(tokens, tokens, ==)), tokens))
+    Histogram:
+    [[['h', 'e', 'l', 'l', 'o'], [1,1,2,2,1]]]
+        Output: (select_width((select(tokens, tokens, ==))))
+    Length:
+    [[[7,2,5],[3,3,3]],[[1],[1]],[[2,0,1,7,3,6,8,20],[8,8,8,8,8,8,8,8]]]
+        Output: (select_width((select(tokens, tokens, true))))
+    Calculate mean of list of numbers:
+    [[[5,10,3,2,43], [12.6, 12.6, 12.6, 12.6, 12.6]],[[1,2], [1.5, 1.5]],[[3,3,3],[3,3,3]]]
+        Output: (aggregate((select(tokens, tokens, true)), tokens))
+    Reverse a string:
+    [[['h', 'i'], ['i', 'h']]]
+        Output: times out
+        Expected: aggregate(select(indices, (select_width((select(tokens, tokens, true)))) - indices - 1, ==), tokens);
+    PERSONAL TODOS:
+    - output several similar programs
+    - 
+    
+    '''
+    
+    args = parse_args()
+    inputs, outs = analyze_examples(args.examples)
+    examples = list(zip(inputs, outs))
+    print("Received the following input and output examples:")
+    print(examples)
+    max_seq_len = 0
+    for i in inputs:
+        max_seq_len = max(len(i), max_seq_len)
+    vocab = get_vocabulary(examples)
+    
+    print("Running synthesizer with")
+    print("Vocab: {}".format(vocab))
+    print("Max sequence length: {}".format(max_seq_len))
+    print("Max weight: {}".format(args.max_weight))
+    
+    program = run_synthesizer(examples, args.max_weight)
+    
+    if program:
+        algorithm = program.to_python()
+        
+        bos = "BOS"
+        model = compiling.compile_rasp_to_model(
+            algorithm,
+            vocab=vocab,
+            max_seq_len=max_seq_len,
+            compiler_bos=bos,
+        )
+        
+        
+        def extract_layer_number(s):
+            match = re.search(r'layer_(\d+)', s)
+            if match:
+                return int(match.group(1)) + 1
+            else:
+                return None
+        
+        layer_num = extract_layer_number(list(model.params.keys())[-1])
+        print(f"The following program has been compiled to a transformer with {layer_num} layer(s):")
+        print(program.str())
+    else:
+        print("No program found.")

testouts.txt

@@ -0,0 +1,55 @@
+Received the following input and output examples:
+[(['h', 'i'], ['h', 'h'])]
+Running synthesizer with
+Vocab: {'h', 'i'}
+Max sequence length: 2
+Max weight: 15
+- Searching level 2 with 4 primitives.
+- Searching level 3 with 4 primitives.
+(select(tokens, tokens, ==))
+[[[True, False], [False, True]]]
+(select(tokens, tokens, true))
+[[[True, True], [True, True]]]
+- Searching level 4 with 6 primitives.
+(select_width((select(tokens, tokens, ==))))
+[[1, 1]]
+(select_width((select(tokens, tokens, true))))
+[[2, 2]]
+- Searching level 5 with 8 primitives.
+- Searching level 6 with 8 primitives.
+- Searching level 7 with 8 primitives.
+- Searching level 8 with 8 primitives.
+- Searching level 9 with 8 primitives.
+(aggregate((select(tokens, tokens, ==)), (select_width((select(tokens, tokens, ==))))))
+[[1.0, 1.0]]
+(aggregate((select(tokens, tokens, ==)), (select_width((select(tokens, tokens, true))))))
+[[2.0, 2.0]]
+(aggregate((select(tokens, tokens, true)), (select_width((select(tokens, tokens, ==))))))
+[[1.0, 1.0]]
+(aggregate((select(tokens, tokens, true)), (select_width((select(tokens, tokens, true))))))
+[[2.0, 2.0]]
+- Searching level 10 with 12 primitives.
+- Searching level 11 with 12 primitives.
+- Searching level 12 with 12 primitives.
+- Searching level 13 with 12 primitives.
+- Searching level 14 with 12 primitives.
+(aggregate((select(tokens, tokens, ==)), (aggregate((select(tokens, tokens, ==)), (select_width((select(tokens, tokens, ==))))))))
+[[1.0, 1.0]]
+(aggregate((select(tokens, tokens, ==)), (aggregate((select(tokens, tokens, ==)), (select_width((select(tokens, tokens, true))))))))
+[[2.0, 2.0]]
+(aggregate((select(tokens, tokens, ==)), (aggregate((select(tokens, tokens, true)), (select_width((select(tokens, tokens, ==))))))))
+[[1.0, 1.0]]
+(aggregate((select(tokens, tokens, ==)), (aggregate((select(tokens, tokens, true)), (select_width((select(tokens, tokens, true))))))))
+[[2.0, 2.0]]
+> c:\users\18084\desktop\cs252r\final_project\tracr-synthesis\rasp_synthesizer.py(94)check_obs_equivalence()
+-> return a_output == b_output
+(Pdb) --KeyboardInterrupt--
+(Pdb) --KeyboardInterrupt--
+(Pdb) --KeyboardInterrupt--
+(Pdb) *** SyntaxError: invalid syntax
+(Pdb) --KeyboardInterrupt--
+(Pdb) *** SyntaxError: invalid syntax
+(Pdb) --KeyboardInterrupt--
+(Pdb) --KeyboardInterrupt--
+(Pdb) *** SyntaxError: invalid syntax
+(Pdb) 

utils.py

@@ -0,0 +1,80 @@
+import subprocess
+import time
+import re
+import ast
+
+# Start the REPL subprocess
+python_exe = '/Users/18084/Desktop/CS252R/final_project/rasp-env-py3.9/Scripts/python.exe' #SETUP THING: replace with path to your python environment
+
+'''
+THE FOLLOWING FUNCTIONS ARE DEPRECATED
+'''
+def clean_carrots(text):
+    pattern = r">>(.*?)>>"
+
+    match = re.search(pattern, text)
+    if match:
+        result = match.group(1).strip()  # .strip() is used to remove any leading/trailing whitespace
+        return result
+
+def parse_output(out):
+    out = clean_carrots(out)
+    out = ast.literal_eval(out)
+    # can arrive as tuple, list, or dictionary
+    # ultimately want to convert everything to list form
+    if isinstance(out, dict):
+        return list(out.values())
+    if isinstance(out, tuple):
+        return list(out)
+    if isinstance(out, list):
+        return list
+    raise Exception("Error executing rasp program.")
+
+def run_repl(command):
+    '''
+    Runs the RASP repl in a separate subprocess.
+    '''
+    process = subprocess.Popen([python_exe, 'RASP/RASP_support/REPL.py'], 
+                            stdin=subprocess.PIPE, 
+                            stdout=subprocess.PIPE, 
+                            stderr=subprocess.PIPE, 
+                            text=True)
+
+    # Send commands to the REPL
+    process.stdin.write(f'{command}\nexit()\n')
+    process.stdin.flush()
+
+    # Check periodically if the subprocess has terminated
+    while True:
+        if process.poll() is not None:
+            # The subprocess has terminated
+            break
+        time.sleep(0.1)  # Wait for a short period (e.g., 0.1 seconds) before checking again
+
+    # Close the subprocess if still running
+    if process.poll() is None:
+        process.terminate()
+
+    # Read output and error
+    output = process.stdout.readlines()
+    error = process.stderr.readlines()
+
+    # Print output and error
+    str_output = ""
+    str_error = ""
+    for line in output:
+        str_output += line.strip() + " "
+    for line in error:
+        str_error += line.strip() + " "
+    
+    str_output = parse_output(str_output)
+    return str_output, str_error
+
+if __name__ == "__main__":
+    command = "select(tokens, tokens, ==)(\"hi\");"
+    res, _res_err = run_repl(command)
+    print(res)
+    
+    command = "selector_width(select(tokens, tokens, ==))(\"hi\");"
+    res, _res_err = run_repl(command)
+    print(res)