Datasets:

Languages:
English
Size:
n<1K
DOI:
Libraries:
License:
miniCodeProps / baseline.py
evanlohn
README updates for reproducibility
cf82b1c
raw
history blame
15.8 kB
import json
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
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
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', 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
mathlib_out, mathlib_env = send_command(lean_repl, 'import Mathlib', env=None, first=True, timeout=30)
num_proved = 0
num_attempted = 0
for prop_name in pwd:
#time.sleep(5)
num_attempted += 1
#if num_attempted < 115:
# continue
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'])
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 + '\n'.join(tac_seq))
for next_tactic, _scr in sorted(next_tactics, key=lambda p: -p[1])[:search_width]:
if prop_name in next_tactic:
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 tactics.
#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, num_gen=4):
#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'
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
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()
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=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)
num_proved = 0
num_attempted = 0
for prop_name in pwd:
num_attempted += 1
#time.sleep(5)
#if num_attempted < 30:
# continue
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
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
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
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:
printl(f'failed to prove {prop_name}')
printl(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 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
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
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(args.bench_file)
if bench_type == 'nextstep':
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':
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)