benchmark and baseline code

baseline.py

@@ -0,0 +1,348 @@
+import json
+import requests
+import time
+import os
+from openai import OpenAI
+
+from utils import make_lean_repl, send_tactic, send_command_icanon, send_command_zsh, get_errs
+
+
+def get_tactics_interactive(goal, prev_file):
+    print(f'output:<{goal}>')
+    print(f'file context: <{prev_file}>')
+    return [(input('give the next tactic to execute:'), 0)]
+
+# the goal is to directly call the llmstep server.py
+def get_tactics_llmstep(goal, prev_file):
+    # this is the function lean calls to interact with the server
+    def suggest(host, tactic_state, prefix, context):
+        data = {'tactic_state': tactic_state, 'prefix': prefix, 'context': context}
+        response = json.loads(requests.post(host, json=data).content)
+        return response['suggestions'] # modified to directly return the suggestion list
+
+    HOST='localhost'
+    PORT='6000'
+    default_host = f'http://{HOST}:{PORT}'
+
+    suggestions = suggest(default_host, goal, '', prev_file) # trying to match what the tactic sends
+    return suggestions
+
+# for benchmarking 'get_tactics' functions that suggest several next possible steps for a given
+# proofstate + optionally file context.
+def benchmark_nextstep(pwd, get_tactics, send_command, search_depth=3, repl_type='zsh'):
+    lean_repl = make_lean_repl(repl_type=repl_type)
+
+    # get the first command out of the way which has a weird "expect" behavior using icanon mode
+    mathlib_out, mathlib_env = send_command(lean_repl, 'import Mathlib', env=None, first=True)
+    
+    num_proved = 0
+    num_attempted = 0
+    for prop_name in pwd:
+        print(prop_name)
+        #time.sleep(5)
+        num_attempted += 1
+        #if num_attempted < 30:
+        #    continue
+        successful_def = False
+        while not successful_def:
+            successful_def = True
+            env = None
+            all_lines = []
+            for _loc, line in pwd[prop_name]:
+                if line.strip() == 'import Mathlib':
+                    outp, env = mathlib_out, mathlib_env
+                else:
+                    outp, env = send_command(lean_repl, line, env=env)
+                if outp is None:
+                    print('restarting repl')
+                    successful_def = False
+                    lean_repl.close()
+                    lean_repl = make_lean_repl(repl_type=repl_type)
+                    mathlib_out, mathlib_env = send_command(lean_repl, 'import Mathlib', env=None, first=True)
+                    break
+                all_lines.append(line)
+
+        assert len(get_errs(outp)) == 0, str(outp.get('messages', []))
+        proofState = int(outp['sorries'][0]['proofState'])
+        goal = outp['sorries'][0]['goal']
+        prev_lines = '\n'.join(all_lines)
+        prev_lines = prev_lines.replace(':= by sorry', ':= by\n')
+        
+        solution_tac_seq = None
+        old_ps = [(goal, proofState, [])]
+        new_ps = []
+        found_proof = False
+        for search_lvl in range(search_depth):
+            if search_lvl > 0:
+                print(f'search at level {search_lvl}')
+            for (curr_goal, ps, tac_seq) in old_ps:
+                next_tactics = get_tactics(curr_goal, prev_lines)
+                for next_tactic, _scr in sorted(next_tactics, key=lambda p: -p[1])[:3]:
+                    print('\n'.join(tac_seq + [next_tactic]))
+                    outp, new_proofState = send_tactic(lean_repl, next_tactic, ps)
+                    if outp is None:
+                        continue # i.e. timeout/error on tactic sending
+                    #print(outp)
+                    error_msgs = get_errs(outp)
+                    if len(error_msgs) > 0:
+                        continue # invalid next proof step. sometimes there are invalid intermediate
+                                 # states that lead to successful proof, but for efficiency we enforce this.
+                    if len(outp['goals']) == 0 and len(error_msgs) == 0:
+                        #print(outp)
+                        found_proof = True
+                        solution_tac_seq = tac_seq + [next_tactic]
+                        break
+                    new_ps.append(('\n'.join(outp['goals']), new_proofState, tac_seq + [next_tactic]))
+                    
+                #print(f'final output: {outp}')
+                if found_proof:
+                    break
+            if found_proof:
+                break
+            old_ps = new_ps
+            new_ps = []
+        
+        
+        if found_proof:
+            num_proved += 1
+            nl = '\n'
+            print(f'prop {prop_name} with goal <{goal}> solved by: <\n {nl.join([str(s) for s in solution_tac_seq])}\n>')
+        else:
+            print(f'failed to prove {prop_name}')
+
+        print(f'proved {num_proved}/{num_attempted}')
+        #exit()
+
+def get_proof_gpt(theorem_defn, goal, context):
+    #openai_api_key = os.environ['OPENAI_API_KEY']
+    client = OpenAI()
+
+    # decided I don't need the goal, it doesn't look very useful in most cases when the theorem statement
+    # and context are given. Future work can confirm or invalidate this.
+    encoded = f'<context>\n{context}\n</context>\n<theorem>\n{theorem_defn}\n</theorem>\n'
+
+    return client.chat.completions.create(
+    model=gpt_model, # see main block
+    messages=[{"role": "system", "content": "You are a Lean 4 expert tasked with completing proofs of program properties. You will be shown the relevant programs and definitions in <context>...</context> tags, the theorem to be proven in <theorem>...</theorem>. Please output your proof containing only Lean 4 proof code between <proof>...</proof> tags. The generated proof should never contain the word `sorry`. Here are some examples:"},
+              {"role": "user", "content": """<context>
+import Mathlib
+inductive MyTree (α: Type) where
+| leaf : MyTree α
+| node : MyTree α → α → MyTree α  →  MyTree α
+
+def tree_size : MyTree α → ℕ
+  | .leaf => 1
+  | .node l _x r => 1 + (tree_size l) + (tree_size r)
+
+def balanced : MyTree α → Prop
+  | .leaf => true
+  | .node l _x r => ((tree_size l) = (tree_size r)) ∧ (balanced l) ∧ (balanced r)
+</context>
+<theorem>
+theorem balanced_tree_size_odd (t: MyTree α) (hb: balanced t): Odd (tree_size t) := by
+</theorem>"""},
+        {"role": "assistant", "content": """<proof>
+  cases t with
+  | leaf => simp [tree_size]
+  | node p x q =>
+    unfold tree_size
+    unfold balanced at hb
+    simp [hb.1]
+</proof>"""}, 
+        {"role": "user", "content": """<context>
+import Mathlib
+inductive MyTree (α: Type) where
+| leaf : MyTree α
+| node : MyTree α → α → MyTree α  →  MyTree α
+
+def balanced : MyTree α → Prop
+  | .leaf => true
+  | .node l _x r => ((tree_size l) = (tree_size r)) ∧ (balanced l) ∧ (balanced r)
+
+def swap_branches : MyTree α → MyTree α
+  | MyTree.leaf => MyTree.leaf
+  | MyTree.node p x q => MyTree.node q x p
+</context>
+<theorem>
+theorem swap_preserves_balance (t: MyTree α) (hb: balanced t): balanced (swap_branches t) := by
+</theorem>"""},
+        {"role": "assistant", "content": """<proof>
+  cases t with
+  | leaf => simp [swap_branches]
+  | node p x q =>
+    simp [swap_branches, balanced] at hb ⊢
+    split
+    { simp [← hb.1] }
+    { split; assumption }
+</proof>"""},
+        {"role": "user", "content": """<context>
+import Mathlib
+inductive PairList where
+| empty : PairList
+| node  : Nat → Nat → PairList → PairList
+
+def len_pairlist : PairList → Nat
+| .empty => 0
+| .node _n1 _n2 l => len_pairlist l + 2
+
+lemma even_plus_two (x: Nat) (h: Even x): Even (x + 2) := by
+  unfold Even at h
+  rcases h with ⟨y, hy⟩
+  use y + 1
+  linarith [hy]
+</context>
+<theorem>
+theorem len_pairlist_even (l: PairList): Even (len_pairlist l) := by
+</theorem>"""},
+        {"role": "assistant", "content": """<proof>
+generalize hl: len_pairlist l = pl
+induction pl using Nat.strong_induction_on generalizing l with
+| h n ih => cases l with
+  | empty => simp [len_pairlist] at hl; simp [←hl];
+  | node n1 n2 l2 =>
+    unfold len_pairlist at hl
+    simp [←hl]
+    apply even_plus_two
+    exact ih (len_pairlist l2) (by linarith [hl]) l2 (by rfl)
+</proof>"""},
+{"role": "user", "content": encoded}]
+).choices[0].message.content.replace('<proof>','').replace('</proof>', '').strip()
+
+# for benchmarking full proof generation methods, where input is 
+# file context, theorem definition, and initial proof state, and output is a full proof of the theorem.
+def benchmark_full_proofgen(pwd, get_proof, send_command, num_gen=5, repl_type='icanon'):
+    lean_repl = make_lean_repl(repl_type=repl_type)
+    # get the first command out of the way which has a weird "expect" behavior using icanon mode
+    mathlib_out, mathlib_env = send_command(lean_repl, 'import Mathlib', env=None, first=True)
+    
+    num_proved = 0
+    num_attempted = 0
+    for prop_name in pwd:
+        print(prop_name)
+        #time.sleep(5)
+        num_attempted += 1
+        #if num_attempted < 30:
+        #    continue
+        successful_def = False
+        penult_env = None
+        while not successful_def:
+            successful_def = True
+            env = None
+            all_lines = []
+            for _loc, line in pwd[prop_name]:
+                penult_env = env
+                if line.strip() == 'import Mathlib':
+                    outp, env = mathlib_out, mathlib_env
+                else:
+                    outp, env = send_command(lean_repl, line, env=env)
+                if outp is None:
+                    print('restarting repl')
+                    successful_def = False
+                    lean_repl.close()
+                    lean_repl = make_lean_repl(repl_type=repl_type)
+                    mathlib_out, mathlib_env = send_command(lean_repl, 'import Mathlib', env=None, first=True)
+                    break
+                all_lines.append(line)
+
+        assert len(get_errs(outp)) == 0, str(outp.get('messages', []))
+        context = '\n\n'.join([line for _loc, line in pwd[prop_name][:-1]])
+        theorem_defn = pwd[prop_name][-1][1].replace('by sorry', 'by\n') # give the llm a clean place to begin generating
+        goal = outp['sorries'][0]['goal']
+        found_proof = False
+        for gen_i in range(num_gen):
+            print(f'generating proof {gen_i}')
+            suggested_proof = get_proof(theorem_defn, goal, context)
+            full_thm = theorem_defn + suggested_proof
+            print('suggested proof: ' + full_thm)
+            outp, _result_env = send_command(lean_repl, full_thm, env=penult_env)
+            if len(get_errs(outp)) == 0:
+                num_proved += 1
+                found_proof = True
+                print('successful proof!')
+                print(f'prop {prop_name} with goal <{goal}> solved by: <\n {suggested_proof}\n>')
+                break
+        if not found_proof:
+            print(f'failed to prove {prop_name}')
+        
+        print(f'proved {num_proved}/{num_attempted}')
+
+
+def parse_benchmark_output(fname, pwd, loc2comm):
+    with open(fname, 'r') as f:
+        lines = f.readlines()
+
+    failures = set()
+    for line in lines:
+        if 'failed to prove' in line:
+            failures.add(line.strip().split(' ')[-1])
+
+    by_score = {i: [0,0] for i in range(1, 6)}
+    by_custom = [0, 0]
+    custom_proved = []
+    all_proved = []
+    results = {}
+    for i in range(1, 87):
+        key = f'prop_{i}' if i >=10 else f'prop_0{i}'
+        if key not in pwd:
+            continue
+        loc = [loc[0] for loc, line in pwd[key] if key in line][0]
+        line_str = int(loc.strip().split(':')[1])
+        comm = loc2comm[line_str-1]
+        print(comm)
+        score = int(comm.split(':')[1].strip().split('/')[0].strip())
+        is_custom = 'custom' in comm
+        results[key] = {'score': score, 'result': key not in failures, 'custom': is_custom}
+        if key in failures:
+            by_score[score][1] += 1
+            if is_custom:
+                by_custom[1] += 1
+            print(f'could not prove {key}')
+            
+        else:
+            by_score[score][0] += 1
+            if is_custom:
+                by_custom[0] += 1
+                custom_proved.append(key)
+            all_proved.append((score, key))
+            print(f'proved {key}')
+
+    print('by score', by_score)
+    print('by custom', by_custom)
+    print('custom proved', custom_proved)
+    print('all proved 5', [name for score, name in all_proved if score == 5])
+    print(f'total: {len(all_proved)}/{len(pwd)}')
+    return results, by_score
+
+def parse_benchmark_input(fname):
+    with open(fname, 'r') as f:
+        lines = f.readlines()
+
+    jl = [json.loads(line.strip()) for line in lines if len(line.strip()) > 0]
+    # dummy locations via enumerate, since they're unused during baseline calculation
+    return {dct['full_name']: list(enumerate(dct['deps'].split('\n\n') + [dct['prop_defn']])) for dct in jl}
+
+if __name__ == '__main__':
+    # if any single command is >1024 characters, use_icanon=True is necessary.
+    # unfortunately there are still some bugs where a theorem is actually proven,
+    # but the messages from Lean REPL indicate an error when using this mode.
+    use_icanon = True 
+    #bench_type = 'fullproof'
+    bench_type = 'nextstep'
+    gpt_model = 'gpt-4-turbo'
+
+    if use_icanon:
+        send_command = send_command_icanon
+        repl_type = 'icanon'
+    else:
+        send_command = send_command_zsh
+        repl_type = 'zsh'
+
+
+    #benchmark_nextstep(pwd, get_tactics_interactive, send_command, repl_type=repl_type) # get_tactics_interactive for testing
+
+    pwd = parse_benchmark_input('codeprops_bench_lemmas.jsonl')
+
+    if bench_type == 'nextstep':
+        benchmark_nextstep(pwd, get_tactics_llmstep, send_command, repl_type=repl_type) # get_tactics_llmstep for benchmarking  
+    elif bench_type == 'fullproof':
+        benchmark_full_proofgen(pwd, get_proof_gpt, send_command, repl_type=repl_type)

extract.py

@@ -0,0 +1,469 @@
+import os
+from enum import Enum
+import pexpect
+import json
+import re
+from tqdm import tqdm 
+import json
+import git
+import pickle
+import requests
+from collections import defaultdict
+
+from utils import make_lean_repl, send_tactic, send_command_icanon, send_command_zsh, BASE_PATH
+
+class ParseState(Enum):
+    defn = 0
+    inductive = 1
+    block_comment = 2
+    prop = 3
+    mutual = 4
+
+def loc_tag(fname, line_ind):
+    return f'{fname}:{line_ind}'
+
+def parse_file(fname):
+    lines = None
+    with open(fname, 'r') as f:
+        lines = f.readlines()
+    imports = []
+    defns = []
+    props = []
+    comments = []
+
+    prev_state = None
+    state = None
+    data = []
+
+    def change_state(new_state, line_ind, line):
+        nonlocal data, state, prev_state
+        route_map = {ParseState.defn: defns, ParseState.inductive: defns, 
+                     ParseState.prop: props, ParseState.block_comment: comments,
+                     ParseState.mutual: defns}
+        if state in route_map:
+            route_map[state].append(data)
+            data = []
+        if new_state in route_map:
+            data = [(loc_tag(fname, line_ind), line)]
+        prev_state = state
+        state = new_state
+
+    for line_ind, line in enumerate(lines):
+        line_str = line.strip()
+        if state == ParseState.block_comment: # end of block comment: reset state
+            if line_str.endswith('-/'):
+                state = prev_state
+                prev_state = None
+                continue
+        elif line_str.startswith('--'): # inline comment: maintain state
+            comments.append((loc_tag(fname, line_ind), line))
+            continue
+        elif line_str.startswith('/-'): # start block comment
+            change_state(ParseState.block_comment, line_ind, line)
+            continue
+        elif line_str.startswith('mutual'):
+            change_state(ParseState.mutual, line_ind, line)
+            continue
+        elif line_str.startswith('end') and state == ParseState.mutual:
+            #manually handle mutual stuff, its pretty annoying
+            data.append((loc_tag(fname, line_ind), line))
+            change_state(None, line_ind, line)
+            continue
+        elif state == ParseState.mutual:
+            data.append((loc_tag(fname,line_ind), line))
+            continue
+        elif line.startswith('import'):
+            assert state is None
+            imports.append(line)
+            continue
+        elif line_str.startswith('def prop'): # one of the propositions to prove
+            change_state(ParseState.prop, line_ind, line)
+        elif line_str.startswith('def') or line_str.startswith('lemma') or line_str.startswith('theorem'): # a function definition
+            change_state(ParseState.defn, line_ind, line)
+        elif line_str.startswith('inductive'):
+            change_state(ParseState.inductive, line_ind, line)
+        elif len(line_str) == 0:
+            change_state(None, line_ind, line)
+        else:
+            data.append((loc_tag(fname,line_ind), line))
+    
+    change_state(None, -1, '') # handle EOF
+
+
+    return imports, defns, props, comments
+
+
+def process_defns(defns):
+    new_defns = []
+    for defn in defns:
+        inds, lines = zip(*defn)
+        prop_text = ''.join(lines)
+        ind = min(inds)
+        max_ind = max(inds)
+
+        if lines[0].strip().startswith('mutual'):
+            # manually process mutual defns
+            names = []
+            for line in lines:
+                if line.strip().startswith('def'):
+                    inner_name = [s for s in line.strip().split(' ') if len(s) > 0][1]
+                    names.append(inner_name)
+                    #names.append(f'_root_.{inner_name}')
+        else:
+
+            names = [[s for s in prop_text.split(' ') if len(s) > 0][1].strip()]
+
+        for name in names:
+            if name.endswith(':'):
+                name = name[:-1]
+            new_defns.append(((ind, max_ind), name, prop_text))
+    return new_defns
+
+# take in a raw parsed prop (list of lines), output the corresponding lemma for a theorem prover to prove
+def process_prop(prop, default_proof=':= by sorry'):
+    inds, lines = zip(*prop)
+    prop_text = ''.join(lines)
+    ind = min(inds)
+    max_ind = max(inds)
+    name = prop_text.split(' ')[1]
+    assert prop_text[:3] == 'def'
+    prop2 = 'theorem' + prop_text[3:]
+    # TBD what default proof should be; different setups might want different things. i.e. tactic mode just wants
+    # a 'by', proof term generation wants nothing, a proof rewriter that expects an initial valid state might want 
+    # 'by sorry'.
+    prop2 = prop2.strip().replace(':=', ':') + f'{default_proof}' 
+    return ((ind, max_ind), name, prop2)
+
+#NOTE: if I eventually choose to handle chained dependencies, I'll want this to return a dictionary representing
+# the dependency graph of imports. As of now I have the code for adding in other LeanSrc import definitions, but
+# I'm not dealing with the import order in my later sort.
+#
+# collect all the (location_tag, definition_text) definitions from other files in LeanSrc specified 
+# by import_names
+def collect_import_defns(import_names):
+    import_names = import_names[:] # don't modify original list
+    defns = []
+    seen = set()
+    while len(import_names) > 0:
+        imp = import_names.pop()
+        if imp in seen:
+            continue
+        seen.add(imp)
+        i, d, p, c = parse_file(f'{BASE_PATH}/{imp}.lean')
+        import_names += [imp_str.split('.')[-1].strip() for imp_str in i if 'LeanSrc' in imp_str]
+        defns += d
+    return defns
+
+#errors I have come across: 
+# "function expected at\n  <ident>\nterm has type"
+# "unknown identifier '<ident>'"
+def match_error(err_str):
+    m1 = re.search('expected at\n\s+(.+)\nterm has', err_str)
+    if m1 is not None:
+        return m1.group(1)
+    m2 = re.search("unknown (identifier|constant) '(.+)'", err_str)
+    if m2 is not None:
+        return m2.group(2)
+    if 'invalid dotted identifier notation' in err_str:
+        return err_str.strip().split(' ')[-1]
+    print(f'ERROR: err string <<{err_str}>> is not a recognized error pattern')
+    exit()
+    return None
+
+# these are a result of other things not being defined, and don't contain semantic information about what definition to add
+# note that I AM NOT IGNORING THESE ERRORS IN THE FINAL PROP WITH DEPS, i.e. I only output the prop w deps once I have
+# no errors at all. These are just ignored for the purpose of finding new dependencies
+ignore_errs = ['equality or iff proof expected', 'invalid occurrence of universe level',
+                'function is not recursive', 'failed to prove termination', 'unsolved goals',
+                'invalid field notation', 'result is not type correct',
+                'invalid argument, variable is not a proposition', 'tactic failed. Possible reasons']
+def collect_relevant_defns(prop, defns, lean_repl, env, import_order):
+    """
+    Collect the functions and type definitions used in a prop from a list of defns sourced from the 
+    current file and potentially from other libraries, although for now I'm not handling mathlib. 
+    This will rely on names being unique, so please don't shadow any names in the files you're importing.
+    """
+    # use _env because we want all definition dependence checks to be based on the original env
+    outp, _env = send_command(lean_repl, prop, env=env) # ignore resulting env; we just want to see the error
+    errors = [m for m in outp['messages'] if m['severity'] == 'error']
+    #print(errors)
+    seen = set()
+    seen_locs = set()
+    all_deps = []
+
+    while True:
+        # reset to original environment
+        env2 = env
+        all_deps = order_deps(all_deps, import_order)
+        errors = []
+        seen_err = set()
+        for defn in all_deps:
+            #print()
+            #print(defn[1])
+            outp, env2 = send_command(lean_repl, defn[1], env=env2)
+            tmp = [(m, defn[1]) for m in outp.get('messages', []) if m['severity'] == 'error' and m['data'] not in seen_err]
+            errors += tmp
+            for m, _ in tmp:
+                seen_err.add(m['data'])
+        # env2 is the environment after all dependencies have been added.
+        #print('new iteration outp:', outp)
+        #print('new iteration errs:', errors)
+        #errors = [m for m in outp.get('messages', []) if m['severity'] == 'error']
+
+        # if the dependencies are added without error, also add in the prop.
+        if len(errors) == 0:
+            outp, env2 = send_command(lean_repl, prop, env=env2)
+            errors = [(m, prop) for m in outp.get('messages', []) if m['severity'] == 'error']
+
+        if len(errors) == 0: # all dependencies plus prop statement does not error
+            break
+
+        while len(errors) > 0:
+            err, err_cause = errors.pop()
+            if any([uerr in err['data'] for uerr in ignore_errs]):
+                continue
+            if 'invalid pattern variable, must be atomic' in err['data']:
+                found_ind = False
+                defn_line = err_cause.split('\n')[0]
+                for ident in defn_line.strip().split(' '):
+                    if ident in defns and ident not in seen:
+                        found_ind = True
+                        cp = err.copy()
+                        
+                        cp['data'] = f"unknown identifier '{ident}'" # spoof a better error message
+                        #print('FOUND INDUCTIVE:', cp['data'])
+                        errors.append((cp, err_cause))
+                if not found_ind:
+                    print('ERROR: failed to resolve inductive type pattern var problem')
+                    exit()
+                continue
+
+            ident_str = match_error(err['data'])
+            ident_str = ident_str.replace('_root_.','')
+            #print(ident_str, ident_str in defns)
+            if ident_str not in defns:
+                print(f'ERROR: couldnt find identifier {ident_str}')
+                print(err)
+                exit()
+                continue
+            if ident_str in seen:
+                continue
+                # don't add the same defn twice
+                #print(f'ERROR: circular dependency: {ident_str}')
+            seen.add(ident_str)
+
+            if defns[ident_str][0] in seen_locs:
+                continue
+            seen_locs.add(defns[ident_str][0])
+            all_deps.append(defns[ident_str])
+
+    return all_deps
+
+def order_deps(defns, import_order):
+    if len(defns) == 0:
+        return defns
+    order_map = {fname: i for i, fname in enumerate(import_order)}
+    line_nums = [int(defn[0][0].split(':')[-1]) for defn in defns]
+    max_line_num = max(line_nums)
+    def import_rank(defn):
+        fpath, line_ind = defn[0][0].split(':')
+        fname = re.search(BASE_PATH + '/(\S+)\.lean', fpath).group(1)
+        return order_map[fname]*max_line_num + int(line_ind)
+    return sorted(defns, key=import_rank)
+
+def extract_file_props(fname, full_path, send_command, default_proof=':= by sorry', repl_type='zsh'):
+    # imports, definitions (code and types), propositions, and comments.
+    # d, p, and c are lists of lists; each sublit contains the original lines of the file that comprise
+    # the definition, proposition, or comment.
+    i, d, p, c = parse_file(full_path)
+
+    imp_names = [imp_str.split('.')[-1].strip() for imp_str in i if 'LeanSrc' in imp_str]
+    imp_d = collect_import_defns(imp_names)
+
+    all_d = imp_d + d 
+    import_order = imp_names + [fname] # imports go first
+    all_d = process_defns(all_d)
+    defns_by_name = {name: (ind, defn) for ind, name, defn in all_d}
+    
+
+    props = [process_prop(prop, default_proof=default_proof) for prop in p]
+    #TODO
+    lemma_props = [(ind, name, defn.split('\n')[0].strip().replace('lemma', 'theorem').replace(':= by', default_proof))
+                   for ind, name, defn in all_d if defn.strip().startswith('lemma')]
+    props = lemma_props # + props
+    #props_by_name = {name: (ind, defn) for ind, name, defn in props}
+    lean_repl = make_lean_repl(repl_type=repl_type)
+
+    props_with_deps = {}
+
+    outp, mathlib_env = send_command(lean_repl, 'import Mathlib', env=None, first=True)
+    ct = 0
+    for prop_loc, prop_name, prop in tqdm(props, desc='analyzing and loading lean code + properties'):
+        ct += 1
+        env = mathlib_env
+
+        all_deps = collect_relevant_defns(prop, defns_by_name, lean_repl, env, import_order)
+
+        for defn in all_deps:
+            print(defn[-1])
+            outp, env = send_command(lean_repl, defn[-1], env=env)
+        print('final output of deps', outp)
+
+        outp, env = send_command(lean_repl, prop, env=env)
+        for message in outp['messages']:
+            if message['severity'] == 'error':
+                print(f'error at prop {prop_name}')
+                print(message)
+                print()
+                exit()
+        props_with_deps[prop_name] = all_deps + [(prop_loc, prop)]
+
+    lean_repl.close()
+    #print(lean_repl.exitstatus, lean_repl.signalstatus)
+    return props_with_deps, c
+
+def output_prop_with_deps(prop, prop_name, folder='LeanSrc/benchmark'):
+    lines = '\n'.join(['import Mathlib'] + [code_lines for _loc, code_lines in prop])
+    with open(os.path.join(folder, prop_name + '.lean'), 'w') as f:
+        f.write(lines)
+
+def convert_file_props(fname, new_fname):
+    i, d, p, c = parse_file(f'{BASE_PATH}/{fname}.lean')
+    imp_names = [imp_str.split('.')[-1].strip() for imp_str in i if 'LeanSrc' in imp_str]
+    imp_d = collect_import_defns(imp_names)
+
+    all_d = imp_d + d 
+    import_order = imp_names + [fname] # imports go first
+    all_d = process_defns(all_d)
+    defns_by_name = {name: (ind, defn) for ind, name, defn in all_d}
+
+    props = [process_prop(prop) for prop in p]
+
+    with open(new_fname, 'w') as f:
+        defn_lines = '\n'.join([defn for _, _, defn in all_d])
+        f.write(defn_lines + '\n')
+
+        prop_lines = '\n'.join([prop for _, _, prop in props])
+        f.write(prop_lines + '\n')
+
+def format_llema_input(pwd, lean_url, lean_sha):
+    dcts = []
+    for prop_name in pwd:
+        
+        lines = '\n'.join(['import Mathlib'] + [code_lines for _loc, code_lines in pwd[prop_name]])
+        lines = lines.replace(':= by sorry', '')
+        loc, _ = pwd[prop_name][-1] # last line comes from the prop of interest
+        fpath = loc.split(':')[0]
+        dct = {'full_name': prop_name,
+               'statement': lines,
+                'url': lean_url,
+                'commit': lean_sha,
+                'file_path': fpath,
+                'split': 'valid'}
+        
+        dcts.append(json.dumps(dct) + '\n')
+    with open('leancb_lemma_inp.jsonl', 'w') as f:
+        f.writelines(dcts)
+
+def pwd_to_json(pwd, send_command, loc2comm, repl_type='zsh'):
+
+    lean_repl = make_lean_repl(repl_type=repl_type)
+
+    outp, mathlib_env = send_command(lean_repl, 'import Mathlib', env=None, first=True)
+    assert len([m for m in outp.get('messages', []) if m['severity'] == 'error']) == 0, str(outp)
+    
+    dcts = []
+    for prop_name in pwd:
+        deps = '\n\n'.join(['import Mathlib'] + [code_lines for _loc, code_lines in pwd[prop_name][:-1]])
+        prop_loc, prop_defn = pwd[prop_name][-1] # last line comes from the prop of interest
+        fpath = prop_loc[0].split(':')[0]
+        cline = int(prop_loc[0].split(':')[1]) - 1
+        score = 5
+        if cline in loc2comm:
+            comm = loc2comm[cline]
+            if 'core: ' in comm: # allow for (S/s)core
+                score = int(comm.split('core:')[1].strip().split('/')[0].strip())
+
+        env = mathlib_env
+        for _loc, code_lines in pwd[prop_name]:
+            outp, env = send_command(lean_repl, code_lines, env=env)
+        ps = outp['sorries'][0]['goal']
+
+        locs = [loc for loc, _code_lines in pwd[prop_name]]
+        fname2line = defaultdict(lambda: 0)
+        for loc in locs:
+            fpath, line_num = loc[1].split(':')
+            fname2line[fpath] = max(fname2line[fpath], int(line_num))
+
+        dct = {'full_name': prop_name,
+               'prop_defn': prop_defn,
+               'prop_loc': prop_loc[0],
+               'score': score,
+               'deps': deps,
+               'proof_state': ps,
+                'file_locs': [(fpath, fname2line[fpath]) for fpath in fname2line]}
+        
+        dcts.append(json.dumps(dct) + '\n')
+    with open('codeprops_bench.jsonl', 'w') as f:
+        f.writelines(dcts)
+
+
+if __name__ == '__main__':
+    #main_fname = 'Properties'
+    main_fname = 'Sorts'
+
+    #convert_file_props(main_fname, os.path.join(folder,'all_props.lean'))
+
+    main_full_path = f'{BASE_PATH}/{main_fname}.lean'
+    """
+    pwd = extract_file_props(main_fname, main_full_path) # props with deps
+    for prop_name in pwd:
+        output_prop_with_deps(pwd[prop_name], prop_name, folder=folder)
+    """
+    
+    use_icanon = True
+
+    if use_icanon:
+        send_command = send_command_icanon
+        repl_type = 'icanon'
+    else:
+        send_command = send_command_zsh
+        repl_type = 'zsh'
+
+
+    rerun = True
+    if rerun:
+        pwd, comments = extract_file_props(main_fname, main_full_path, send_command, repl_type=repl_type) # props with deps
+        with open(f'comm_{main_fname}.pkl', 'wb') as f:
+            pickle.dump(comments, f)
+        with open(f'pwd_{main_fname}.pkl', 'wb') as f:
+            pickle.dump(pwd, f)
+    else:
+        with open(f'pwd_{main_fname}.pkl', 'rb') as f:
+            pwd = pickle.load(f)
+        with open(f'comm_{main_fname}.pkl', 'rb') as f:
+            comments = pickle.load(f)
+
+    loc2comm = {}
+    for loc, comm in comments:
+        fname, line_str = loc.strip().split(':')
+        if fname != main_full_path:
+            continue
+        loc2comm[int(line_str.strip())] = comm
+
+    # use to test specific props
+    #pwd_spec = {}
+    #test_pname = 'prop_29'
+    #pwd_spec[test_pname] = pwd[test_pname]
+    #pwd = pwd_spec
+
+    pwd_to_json(pwd, send_command, loc2comm, repl_type=repl_type)
+        
+    #data, by_score = parse_benchmark_output('bench_out_pythia.txt', pwd, loc2comm)
+
+    #sorries = outp['sorries']
+    #for sorry in sorries:
+    #    ps = sorry['proofState']
+    #    # also has 'pos', 'endPos'
+    #    goal = sorry['goal']
+    #    send_tactic

utils.py

@@ -0,0 +1,186 @@
+import pexpect
+import json_stream
+import json
+
+LEAN_REPL_CMD = 'lake env ../repl/.lake/build/bin/repl'
+SHELL_CMD = '/bin/sh' #zsh doesn't play well with non-canonical input: https://github.com/samapriya/geeup/issues/41
+BASE_PATH = 'LeanSrc/LeanSrc'
+
+def make_lean_repl(repl_type='zsh'):
+    # there are maximum line lengths that can be sent over tty, this will cause some things we send to 
+    # lean repl to be cut off at e.g. 1024 characters for MacOS unless we use this workaround.
+    # See https://pexpect.readthedocs.io/en/stable/api/pexpect.html#pexpect.spawn.send
+    print('making repl')
+    if repl_type == 'icanon':
+        lean_repl = pexpect.spawn(SHELL_CMD, cwd='LeanSrc', maxread=5000, timeout=20, echo=False)
+        lean_repl.sendline('stty -icanon') # this is the magic that allows a bunch of chars to be sent
+        lean_repl.sendline(LEAN_REPL_CMD)
+        print(lean_repl.readline())
+        print(lean_repl.readline())
+    elif repl_type == 'zsh':
+        lean_repl = pexpect.spawn(LEAN_REPL_CMD,cwd='LeanSrc', maxread=1025, timeout=5)
+
+    return lean_repl
+
+# To reliably read multiple json objects from a single byte string where the objects are 
+# separated by newlines but the content also contains newlines, we treat the byte string
+# as a stream using the json-stream python library, and consume from the stream repeatedly until
+# we reach the end of the byte array. 
+#
+# The simplest thing to do is just feed json-stream the byte array one byte at a time, but this
+# produces errors due to multi-byte unicode characters being split. So, we solve this in another
+# simple way: produce chunks up to and including the next '}' byte. This makes sure weird byte sequences
+# get sent together and thus decoded correctly.
+def json_stream_itr(bstr):
+    start = 0
+    for end in range(len(bstr)):
+        #print(bstr[end:end+1], b'}')
+        if bstr[end:end+1] == b'}':
+            yield bstr[start: end + 1]
+            start = end + 1
+
+def load_mult_json(jsons):
+    #NOTE: when using the non-canonical input mode and /bin/sh to spawn lean repl,
+    # sometimes multiple json lines get output! I collect them all into a single 
+    # dictionary to return.
+    itr = json_stream_itr(jsons)
+    ps_out = {'messages': []}
+    while True:
+        try:
+            data = json_stream.load(itr, persistent=True)
+        except StopIteration:
+            break
+        data.read_all()
+        data = json_stream.to_standard_types(data)
+        for k in data:
+            # special case: for some reason when their is a single message the key is not plural, and 
+            # is just a string, which is a problem for later when I try to look at the error severity.
+            if k == 'message': 
+                if data[k].strip().startswith('Lean error:'):
+                    dct = {'severity': 'error', 'data': data[k].replace('Lean error:', '')}
+                else:
+                    dct = {'severity': 'warning', 'data': data[k]}
+                    print('got unexpected non-error message', dct) #TODO: if these don't occur in practice we can delete this
+                    exit()
+                ps_out['messages'].append(dct)
+            elif isinstance(data[k], list) and k in ps_out:
+                ps_out[k].extend(data[k])
+            else:
+                assert k not in ps_out, k +',' +str(ps_out[k])
+                ps_out[k] = data[k]
+        #ps_out = json_stream.to_standard_types(ps_out)
+        #print('yo', ps_out)
+
+    #ps_out = json.loads(output)
+    assert ps_out is not None, 'parsing failed: ' + jsons.decode()
+    print('parsed output:', ps_out)
+    return ps_out
+
+def make_repl_command(def_str, env=None):
+    jsn = {'cmd': def_str}
+    if env is not None:
+        jsn['env'] = env
+    return json.dumps(jsn)
+
+# This is the standard way to send commands to lean repl using most normal shells in canonical input mode.
+# unfortunately, in canonical input mode there is a maximum character limit that can be sent over terminal:
+# see https://pexpect.readthedocs.io/en/stable/api/pexpect.html#pexpect.spawn.send for more details.
+# unfortunately this can't be solved by just chunking up the message to send; we're not sure why, but 
+# lean repl stubbornly insists it has only received the first 1024 (on Mac) characters. 
+#
+# you can use send_command_icanon to handle sending longer strings, although we have found that the messages
+# lean repl sends change for some reason, causing some inconsistencies in how we parse successful or failed proofs.
+def send_command_zsh(repl, command, env=None, timeout=5, first=False):
+    rpl_comm = make_repl_command(command, env=env)
+    #print(rpl_comm)
+    """
+    num_splits = len(rpl_comm)//1024 + 1
+    for split in range(num_splits):
+    #print(rpl_comm) # NOTE: uncomment to see everything being sent to lean repl
+        spl_comm = rpl_comm[split*1024:(split+1)*1024]
+        print(spl_comm)
+        
+        #print('sent and expecting:')
+        #print(len(rpl_comm), rpl_comm)
+        if split < num_splits - 1:
+            repl.sendline(spl_comm)
+        else:
+            repl.sendline(spl_comm)
+            repl.expect_exact(rpl_comm+'\r\n')
+    """
+    #print(repl.readline())
+    #repl.sendline()
+    #repl.expect_exact('\r\n')
+    #print('sup', repl.readline())
+    repl.sendline(rpl_comm)
+    repl.expect_exact(rpl_comm + '\r\n')
+
+    repl.sendline()
+    repl.expect_exact('\r\n')
+
+    _index = repl.expect('env": \d+\}', timeout=timeout)
+    env_str = repl.match.group().decode()
+    new_env = int(env_str.split(':')[1].strip()[:-1])
+    output = repl.before + repl.match.group()
+    #print('js outp', output)
+    return load_mult_json(output), new_env
+
+
+def send_command_icanon(repl, command, env=None, timeout=20, first=False):
+    print('sending command:', command)
+    rpl_comm = make_repl_command(command, env=env)
+        
+    repl.sendline(rpl_comm+'\n')
+    if first:
+        repl.expect_exact('~>')
+        first = False
+    else:
+        try:
+            repl.expect_exact('\r\n\r\n')
+        except pexpect.exceptions.TIMEOUT as e:
+            print('did not find newlines')
+    try:
+        _index = repl.expect('env": \d+\}', timeout=timeout)
+        command_sent = True
+    except pexpect.exceptions.TIMEOUT as e:
+        print('did not find env in output')
+        return None, None
+        
+    env_str = repl.match.group().decode()
+    new_env = int(env_str.split(':')[1].strip()[:-1])
+    output = repl.before + repl.match.group()
+    return load_mult_json(output), new_env
+
+def make_repl_tactic(tac, proofState):
+    return json.dumps({'tactic': tac, 'proofState': proofState})
+
+def send_tactic(repl, tactic, proofState):
+    rpl_comm = make_repl_tactic(tactic, proofState)
+
+    #repl.sendline(rpl_comm)
+    #repl.expect_exact(rpl_comm + "\r\n")
+    #repl.sendline()
+    #repl.expect_exact("\r\n")
+    repl.sendline(rpl_comm+'\n')
+    
+    # the icanon mode sometimes sends a single dict with just one field: 'message'.
+    # when we get that with a lean error, the tactic failed so we return None
+    _index = repl.expect('(]})|(\"}\r\n\r\n)', timeout=10)
+
+
+    #ps_str = repl.match.group().decode()
+    #new_ps = int(ps_str.split(':')[1].strip()[:-1])
+    output = repl.before + repl.match.group()
+    #if verbose: 
+    #print('js outp 2', output)
+    ps_out = load_mult_json(output)
+    print('ps out', ps_out)
+    if 'proofState' not in ps_out:
+        return None, None
+    return ps_out, ps_out['proofState']
+    #except pexpect.exceptions.TIMEOUT:
+    #    print("FAILED DUE TO TIMEOUT")
+    #    return None, None
+
+def get_errs(outp):
+    return [m for m in outp.get('messages', []) if m.get('severity', 'error') == 'error']