README updates for reproducibility

README.md

@@ -1,6 +1,7 @@
 ---
 license: apache-2.0
 ---
+# Getting Started
 First install [Lean 4](https://leanprover-community.github.io/get_started.html). Then clone this repo:
 
 `git clone --recurse-submodules https://huggingface.co/datasets/elohn/miniCodeProps` 
@@ -13,6 +14,26 @@ After cloning the repo, you will need to install [Lean REPL](https://github.com/
 The `extract.py` script is used only to create the json-formatted benchmark.
 
 The `baseline.py` script contains the code we used to get our baseline results. It shows how to interact with Lean Repl programmatically, although some interactions are still somewhat buggy in that the repl will send i.e. an extra newline or weirdly formatted message that requires our script to restart the repl.
-Regardless, if you would like to use our setup, We ran our baselines using [LLMStep](https://github.com/wellecks/llmstep). However, our code also includes a natural place to write your own function to generate tactics given the goal and file context (see `get_tactics_llmstep` in `baseline.py`). We modified the LLMStep server to return average suggestion log-probabilities per suggestion to implement best-first search; we will publish our fork of that soon as well.
+Regardless, if you would like to use our setup, We ran our baselines using [LLMStep](https://github.com/wellecks/llmstep). However, our code also includes a natural place to write your own function to generate tactics given the goal and file context (see `get_tactics_llmstep` in `baseline.py`). We [modified the LLMStep server](https://github.com/evanlohn/llmstep) to return average suggestion log-probabilities per suggestion to implement best-first search.
 
+# Reproducing Baselines
 
+First, ensure that you have installed Lean and Lean REPL as detailed above. Before running `baseline.py` with any arguments, check that your OS has been set at the top of `utils.py`. At the moment we support interacting with Lean in MacOS and Ubuntu (20.04).
+
+## Next-Step Baselines
+Our experiments were run on an A100 GPU. Smaller GPUs may not be able to run Llemma7B, but will likely work with Pythia and ntp-context.
+
+Clone [our fork of LLMStep](https://github.com/evanlohn/llmstep). After following the LLMStep setup instructions, 
+- For Pythia2.8B, run `python3 python/server_vllm.py` (or, if CPU-bound, run `python3 python/server.py`)
+- For Llemma7B, run `python3 python/server_llemma.py`
+- For ntp-context-1.3B, run `python3 python/server_context.py`
+
+In another terminal, run `python baseline.py --bench_type nextstep`
+
+## Full-Proof Baseline
+run `export OPENAI_API_KEY=<your key here>`. 
+Then, simply run 
+`python3 baseline.py`
+You can also specify which openai LLM to use for proof generation via
+`python3 baseline.py --gpt_model <your model name>`
+although our tests only used gpt-4-turbo.

baseline.py

@@ -3,6 +3,7 @@ import requests
 import time
 import os
 from openai import OpenAI
+import argparse
 
 from utils import make_lean_repl, send_tactic, send_command_icanon, send_command_zsh, get_errs
 
@@ -27,9 +28,38 @@ def get_tactics_llmstep(goal, prev_file):
     suggestions = suggest(default_host, goal, '', prev_file) # trying to match what the tactic sends
     return suggestions
 
+def send_prop_defn(lean_repl, pwd, prop_name, mathlib_out, mathlib_env):
+    print(prop_name)
+    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)
+    return lean_repl, mathlib_out, mathlib_env, outp, env, penult_env, all_lines
+
 # 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, search_width=10, repl_type='zsh'):
+def benchmark_nextstep(pwd, get_tactics, send_command, search_depth=3, search_width=10, repl_type='zsh', logfile=None):
+    assert logfile is not None
+    def printl(*args, **kwargs):
+        print(*args, **kwargs)
+        print(*args, **kwargs, file=logfile)
+    
     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
@@ -38,29 +68,11 @@ def benchmark_nextstep(pwd, get_tactics, send_command, search_depth=3, search_wi
     num_proved = 0
     num_attempted = 0
     for prop_name in pwd:
-        print(prop_name)
         #time.sleep(5)
         num_attempted += 1
         #if num_attempted < 115:
         #    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, timeout=30)
-                    break
-                all_lines.append(line)
+        lean_repl, mathlib_out, mathlib_env, outp, env, penult_env, all_lines = send_prop_defn(lean_repl, pwd, prop_name, mathlib_out, mathlib_env)
 
         assert len(get_errs(outp)) == 0, str(outp.get('messages', []))
         proofState = int(outp['sorries'][0]['proofState'])
@@ -116,7 +128,7 @@ def benchmark_nextstep(pwd, get_tactics, send_command, search_depth=3, search_wi
         print(f'proved {num_proved}/{num_attempted}')
         #exit()
 
-def get_proof_gpt(theorem_defn, goal, context):
+def get_proof_gpt(theorem_defn, goal, context, num_gen=4):
     #openai_api_key = os.environ['OPENAI_API_KEY']
     client = OpenAI()
 
@@ -124,8 +136,9 @@ def get_proof_gpt(theorem_defn, goal, context):
     # 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(
+    ret = client.chat.completions.create(
     model=gpt_model, # see main block
+    n=num_gen,
     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
@@ -209,11 +222,16 @@ induction pl using Nat.strong_induction_on generalizing l with
     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()
+)#.choices[0].message.content.replace('<proof>','').replace('</proof>', '').strip()
+    return [m.message.content.replace('<proof>','').replace('</proof>', '').strip() for m in ret.choices]
 
 # 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'):
+def benchmark_full_proofgen(pwd, get_proof, send_command, num_gen=8, repl_type='icanon', logfile=None):
+    assert logfile is not None, 'pass in a file object to write results to'
+    def printl(*args, **kwargs):
+        print(*args, **kwargs)
+        print(*args, **kwargs, file=logfile)
     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)
@@ -221,53 +239,44 @@ def benchmark_full_proofgen(pwd, get_proof, send_command, num_gen=5, repl_type='
     num_proved = 0
     num_attempted = 0
     for prop_name in pwd:
-        print(prop_name)
-        #time.sleep(5)
         num_attempted += 1
+        #time.sleep(5)
         #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)
+        lean_repl, mathlib_out, mathlib_env, outp, env, penult_env, all_lines = send_prop_defn(lean_repl, pwd, prop_name, mathlib_out, mathlib_env)
 
         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)
+        sugg_proofs = get_proof(theorem_defn, goal, context, num_gen=num_gen)
+        for gen_i, suggested_proof in enumerate(sugg_proofs):
+            printl(f'generated proof {gen_i}')
+            if prop_name in suggested_proof:
+                printl('suggested proof used proof name, skipping')
+                continue # although this in theory Can be correct, LEAN DOES NOT CORRECTLY THROW ERRORS when the theorem name is used in a proof. 
+                         # in fact, Lean REPL will return a proofstate with empty goals and no errors! This creates false positives, so we skip these proofs.
+            if 'sorry' in suggested_proof or 'admit' in suggested_proof:
+                printl('suggested proof uses sorry/admit, skipping')
+                continue # this also isn't perfect, as I'm throwing out proofs with 'sorry' in a comment, for example.
+                         # but, it's better than having false positives.
+                         # although I explicitly warn against sorry in the prompt, they still pop up sometimes.
             full_thm = theorem_defn + suggested_proof
-            print('suggested proof: ' + full_thm)
+            printl('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>')
+                printl('successful proof!')
+                printl(f'prop {prop_name} with goal <{goal}> solved by: <\n {suggested_proof}\n>')
                 break
+            else:
+                printl('errors:', get_errs(outp))
         if not found_proof:
-            print(f'failed to prove {prop_name}')
+            printl(f'failed to prove {prop_name}')
         
-        print(f'proved {num_proved}/{num_attempted}')
+        printl(f'proved {num_proved}/{num_attempted}')
 
 
 def parse_benchmark_output(fname, pwd, loc2comm):
@@ -326,12 +335,20 @@ def parse_benchmark_input(fname):
 
 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,
+    # unfortunately there may still be 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'
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('bench_type', type=str, default='fullproof')
+    parser.add_argument('gpt_model', type=str, default='gpt-4-turbo')
+    parser.add_argument('bench_file', type=str, default='codeprops_bench_ps.jsonl')
+    
+    args = parser.parse_args()
+    assert args.bench_type in ['fullproof', 'nextstep']
+        
+    bench_type = args.bench_type
+    gpt_model = args.gpt_model
 
     if use_icanon:
         send_command = send_command_icanon
@@ -340,13 +357,14 @@ if __name__ == '__main__':
         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_ps.jsonl')
+    pwd = parse_benchmark_input(args.bench_file)
 
     if bench_type == 'nextstep':
-        benchmark_nextstep(pwd, get_tactics_llmstep, send_command, repl_type=repl_type) # get_tactics_llmstep for benchmarking  
+        with open(f'logfile_nextstep.txt', 'w') as logf:
+            benchmark_nextstep(pwd, get_tactics_llmstep, send_command, repl_type=repl_type, logfile=logf) # get_tactics_llmstep for benchmarking  
     elif bench_type == 'fullproof':
-        benchmark_full_proofgen(pwd, get_proof_gpt, send_command, repl_type=repl_type)
+        with open(f'logfile_{gpt_model}.txt', 'w') as logf:
+            benchmark_full_proofgen(pwd, get_proof_gpt, send_command, repl_type=repl_type, logfile=logf)