itp-interface 1.0.0__py3-none-any.whl

itp_interface/lean_server/lean_utils.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+
+import sys
+
+root_dir = f"{__file__.split('itp_interface')[0]}"
+if root_dir not in sys.path:
+    sys.path.append(root_dir)
+import os
+import re
+import typing
+from itp_interface.lean_server.lean_context import Obligation, ProofContext
+
+class Lean3Utils:
+    lean_internal_lib_cmd = "elan which lean"
+    theorem_lemma_search_regex = re.compile(r"(theorem|lemma) ([\w+|\d+]*) ([\S|\s]*?):=")
+    proof_context_separator = "⊢"
+    proof_context_regex = r"((\d+) goals)*([\s|\S]*?)\n\n"
+    goal_regex = rf"([\s|\S]*?){proof_context_separator}([\s|\S]*)"
+
+    def remove_comments(text: str) -> str:
+        # NOTE: This will ONLY work correctly if the comments are well-formed
+        # we will need stack based parsing to handle incomplete comments, this faster
+        # when we know that the file compiles
+        # Remove comments
+        #1. First remove all nested comments
+        #2. Then remove all single line comments
+        # Comments are of the form:
+        # 1. /- ... -/
+        # 2. -- ...
+        # Let's do 1
+        # First, let's find all the comments
+        new_text = []
+        idx = 0
+        while idx < len(text):
+            if idx < len(text) - 1 and text[idx] == '/' and text[idx+1] == '-':
+                # We found a comment
+                # Find the end of the comment
+                end_of_comment_idx = idx + 2
+                while end_of_comment_idx < len(text) and \
+                    not (text[end_of_comment_idx] == '-' and \
+                    end_of_comment_idx + 1 < len(text) and \
+                    text[end_of_comment_idx + 1] == '/'):
+                    end_of_comment_idx += 1
+                if end_of_comment_idx >= len(text):
+                    # Unfinished comment
+                    new_text.extend(text[idx:end_of_comment_idx])
+                    idx = end_of_comment_idx
+                else:
+                    # Remove the comment
+                    idx = end_of_comment_idx + 2
+            if idx < len(text):
+                new_text.append(text[idx])
+                idx += 1
+        text = "".join(new_text)
+        new_text = []
+        # Now let's do 2
+        idx = 0
+        while idx < len(text):
+            if idx < len(text) - 1 and text[idx] == '-' and text[idx+1] == '-':
+                # We found a comment
+                # Find the end of the comment
+                end_of_comment_idx = idx + 2
+                while end_of_comment_idx < len(text) and text[end_of_comment_idx] != '\n':
+                    end_of_comment_idx += 1
+                if end_of_comment_idx >= len(text):
+                    # Unfinished comment
+                    new_text.extend(text[idx:end_of_comment_idx])
+                # Remove the comment
+                idx = end_of_comment_idx
+            if idx < len(text):
+                new_text.append(text[idx])
+                idx += 1
+        text = "".join(new_text)
+        return text
+    
+    def get_lean_root_path() -> str:
+        lean_exe = os.popen(Lean3Utils.lean_internal_lib_cmd).read().strip()
+        lean_bin_path = os.path.dirname(lean_exe)
+        lean_root_path = os.path.dirname(lean_bin_path)
+        return lean_root_path
+
+    def get_lean_lib_path() -> str:
+        lean_root_path = Lean3Utils.get_lean_root_path()
+        lean_lib_path = os.path.join(lean_root_path, "lib", "lean", "library")
+        return lean_lib_path
+    
+    def find_theorems_with_namespaces(text: str) -> typing.List[typing.Tuple[str, str, str]]:
+        idx = 0
+        theorems = []
+        lines = text.split('\n')
+        current_namespace = None
+        while idx < len(lines):
+            line = lines[idx]
+            if line.startswith("namespace"):
+                current_namespace = line[len("namespace"):].strip()
+                # Find the end of the namespace
+                end_of_namespace_idx = idx + 1
+                end_line = lines[end_of_namespace_idx]
+                while end_line is not None and not end_line.startswith("end") and not end_line.endswith(current_namespace):
+                    end_of_namespace_idx += 1
+                    end_line = lines[end_of_namespace_idx] if end_of_namespace_idx < len(lines) else None
+                if end_line is not None:
+                    namespace_content = " ".join(lines[idx:end_of_namespace_idx+1])
+                    for name, dfn in Lean3Utils.find_theorems(namespace_content):
+                        theorems.append((current_namespace, name, dfn))
+                idx = end_of_namespace_idx + 1
+            else:
+                idx += 1
+        return theorems
+    
+    def find_theorems(text: str) -> typing.List[typing.Tuple[str, str]]:
+        matches = Lean3Utils.theorem_lemma_search_regex.findall(text)
+        theorems = []
+        for match in matches:
+            name = str(match[1]).strip()
+            dfn = str(match[2]).strip()
+            name = name.strip(':')
+            dfn = dfn.strip(':')
+            theorems.append((name, dfn))
+        return theorems
+
+    def parse_proof_context_human_readable(proof_context_str: str) -> ProofContext:
+        if len(proof_context_str) == 0 and Lean3Utils.proof_context_separator not in proof_context_str:
+            return None
+        if proof_context_str == "no goals":
+            return ProofContext.empty()
+        proof_context_str = proof_context_str.strip()
+        proof_context_str += "\n\n"
+        all_matches = re.findall(Lean3Utils.proof_context_regex, proof_context_str, re.MULTILINE)
+        goal_strs = []
+        total_goal_cnt = 0
+        for _, goal_cnt, goal_str in all_matches:
+            if len(goal_cnt) > 0:
+               total_goal_cnt = int(goal_cnt)
+            goal_str = goal_str.strip()
+            goal_strs.append(goal_str)
+        if total_goal_cnt > 0:
+            assert len(goal_strs) == total_goal_cnt, f"Total goal count {total_goal_cnt} does not match the number of goals {len(goal_strs)}"
+        else:
+            assert len(goal_strs) == 1, f"Total goal count {total_goal_cnt} does not match the number of goals {len(goal_strs)}"
+            total_goal_cnt = 1
+        assert len(goal_strs) == total_goal_cnt, f"Total goal count {total_goal_cnt} does not match the number of goals {len(goal_strs)}"
+        goals = []
+        for goal_str in goal_strs:
+            goal = Lean3Utils.parse_goal(goal_str)
+            goals.append(goal)
+        return ProofContext(goals, [], [], [])
+
+    def parse_goal(goal_str: str):
+        goal_str = goal_str.strip()
+        goal = ""
+        hyps_goals = re.findall(Lean3Utils.goal_regex, goal_str, re.MULTILINE)
+        assert len(hyps_goals) == 1, f"Found more than one goal in the goal string: {goal_str}"
+        hypotheses_str, goal = hyps_goals[0]
+        hypotheses_str = hypotheses_str.strip()
+        goal = goal.strip()
+        hypotheses = [hyp.rstrip(',') for hyp in hypotheses_str.split("\n")]
+        goal = Obligation(hypotheses, goal)
+        return goal
+
+if __name__ == '__main__':
+    text = """
+    -- This is a comment
+    /- This is a nested comment -/
+    theorem foo : 1 = 1 := rfl
+    lemma bar : 2 = 2 := rfl
+    """
+    print("Testing Lean3Utils")
+    print("-"*20)
+    print("Testing Lean3Utils.remove_comments")
+    print("Before:")
+    print(text)
+    print("After:")
+    print(Lean3Utils.remove_comments(text))
+    print("-"*20)
+    print("Testing Lean3Utils.get_lean_root_path")
+    print(Lean3Utils.get_lean_root_path())
+    print("-"*20)
+    print("Testing Lean3Utils.get_lean_lib_path")
+    print(Lean3Utils.get_lean_lib_path())
+    print("-"*20)
+    print("Testing Lean3Utils.find_theorems")
+    lib_path = Lean3Utils.get_lean_lib_path()
+    init_data_name = "init/data/array/basic.lean"
+    init_data_path = os.path.join(lib_path, init_data_name)
+    with open(init_data_path, 'r') as f:
+        text = f.read()
+    print(f"Testing Lean3Utils.find_theorems on {init_data_name}")
+    for name, dfn in Lean3Utils.find_theorems(text):
+        print(f"{name}: {dfn}")
+    print("-"*20)
+    print("Testing Lean3Utils.find_theorems_with_namespaces")
+    for namespace, name, dfn in Lean3Utils.find_theorems_with_namespaces(text):
+        print(f"[{namespace}]::{name}: {dfn}")
+    print("-"*20)
+    # print(text)
+
+    # print(Lean3Utils.find_theorems(text))
+    # print(Lean3Utils.find_theorems_with_namespaces(text))

itp_interface/lean_server/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

itp_interface/main/config/afp_data_gen.yaml

@@ -0,0 +1,14 @@
+defaults:
+  # - benchmark: simple_benchmark_lean_training_data
+  # - run_settings: default_lean_data_generation_transforms
+  - benchmark: afp_isabelle
+  - run_settings: default_isabelle_data_generation_transforms
+  - env_settings: no_retrieval
+  - override hydra/job_logging: 'disabled'
+
+run_settings:
+ output_dir: <root>/data/proofsteps/afp
+ train_eval_test_split:
+   - 0.925
+   - 0.0375
+   - 0.0375

itp_interface/main/config/benchmark/CompCert.yaml

@@ -0,0 +1,366 @@
+name: CompCert
+num_files: 177
+language: COQ
+few_shot_data_path_for_retrieval: null
+few_shot_metadata_filename_for_retrieval: null
+dfs_data_path_for_retrieval: null
+dfs_metadata_filename_for_retrieval: local.meta.json
+setup_cmds:
+  - opam env --switch=CompCert --set-switch
+datasets:
+  - project: <root>/data/repos/CompCert
+    files:
+    - path: flocq/IEEE754/Bits.v
+      theorems: '*'
+    - path: flocq/IEEE754/Binary.v
+      theorems: '*'
+    - path: flocq/Prop/Round_odd.v
+      theorems: '*'
+    - path: flocq/Prop/Plus_error.v
+      theorems: '*'
+    - path: flocq/Prop/Div_sqrt_error.v
+      theorems: '*'
+    - path: flocq/Prop/Sterbenz.v
+      theorems: '*'
+    - path: flocq/Prop/Relative.v
+      theorems: '*'
+    - path: flocq/Prop/Mult_error.v
+      theorems: '*'
+    - path: flocq/Prop/Double_rounding.v
+      theorems: '*'
+    - path: flocq/Calc/Operations.v
+      theorems: '*'
+    - path: flocq/Calc/Bracket.v
+      theorems: '*'
+    - path: flocq/Calc/Round.v
+      theorems: '*'
+    - path: flocq/Calc/Div.v
+      theorems: '*'
+    - path: flocq/Calc/Sqrt.v
+      theorems: '*'
+    - path: flocq/Core/Zaux.v
+      theorems: '*'
+    - path: flocq/Core/Float_prop.v
+      theorems: '*'
+    - path: flocq/Core/Round_pred.v
+      theorems: '*'
+    - path: flocq/Core/FLX.v
+      theorems: '*'
+    - path: flocq/Core/Raux.v
+      theorems: '*'
+    - path: flocq/Core/FLT.v
+      theorems: '*'
+    - path: flocq/Core/Digits.v
+      theorems: '*'
+    - path: flocq/Core/FIX.v
+      theorems: '*'
+    - path: flocq/Core/FTZ.v
+      theorems: '*'
+    - path: flocq/Core/Defs.v
+      theorems: '*'
+    - path: flocq/Core/Ulp.v
+      theorems: '*'
+    - path: flocq/Core/Round_NE.v
+      theorems: '*'
+    - path: flocq/Core/Core.v
+      theorems: '*'
+    - path: flocq/Core/Generic_fmt.v
+      theorems: '*'
+    - path: MenhirLib/Validator_safe.v
+      theorems: '*'
+    - path: MenhirLib/Grammar.v
+      theorems: '*'
+    - path: MenhirLib/Interpreter_complete.v
+      theorems: '*'
+    - path: MenhirLib/Validator_classes.v
+      theorems: '*'
+    - path: MenhirLib/Automaton.v
+      theorems: '*'
+    - path: MenhirLib/Interpreter.v
+      theorems: '*'
+    - path: MenhirLib/Alphabet.v
+      theorems: '*'
+    - path: MenhirLib/Main.v
+      theorems: '*'
+    - path: MenhirLib/Validator_complete.v
+      theorems: '*'
+    - path: MenhirLib/Interpreter_correct.v
+      theorems: '*'
+    - path: driver/Complements.v
+      theorems: '*'
+    - path: driver/Compiler.v
+      theorems: '*'
+    - path: driver/Compopts.v
+      theorems: '*'
+    - path: x86/Asmgenproof.v
+      theorems: '*'
+    - path: x86/ConstpropOp.v
+      theorems: '*'
+    - path: x86/Asm.v
+      theorems: '*'
+    - path: x86/ConstpropOpproof.v
+      theorems: '*'
+    - path: x86/Builtins1.v
+      theorems: '*'
+    - path: x86/ValueAOp.v
+      theorems: '*'
+    - path: x86/SelectLongproof.v
+      theorems: '*'
+    - path: x86/Op.v
+      theorems: '*'
+    - path: x86/Machregs.v
+      theorems: '*'
+    - path: x86/Stacklayout.v
+      theorems: '*'
+    - path: x86/CombineOpproof.v
+      theorems: '*'
+    - path: x86/SelectOp.v
+      theorems: '*'
+    - path: x86/Asmgenproof1.v
+      theorems: '*'
+    - path: x86/SelectOpproof.v
+      theorems: '*'
+    - path: x86/SelectLong.v
+      theorems: '*'
+    - path: x86/Asmgen.v
+      theorems: '*'
+    - path: x86/Conventions1.v
+      theorems: '*'
+    - path: x86/CombineOp.v
+      theorems: '*'
+    - path: x86/NeedOp.v
+      theorems: '*'
+    - path: backend/SelectDivproof.v
+      theorems: '*'
+    - path: backend/Inlining.v
+      theorems: '*'
+    - path: backend/Registers.v
+      theorems: '*'
+    - path: backend/Stackingproof.v
+      theorems: '*'
+    - path: backend/Linearizeproof.v
+      theorems: '*'
+    - path: backend/Cminortyping.v
+      theorems: '*'
+    - path: backend/CSEproof.v
+      theorems: '*'
+    - path: backend/Cminor.v
+      theorems: '*'
+    - path: backend/Allocproof.v
+      theorems: '*'
+    - path: backend/Stacking.v
+      theorems: '*'
+    - path: backend/Mach.v
+      theorems: '*'
+    - path: backend/CleanupLabelsproof.v
+      theorems: '*'
+    - path: backend/SelectDiv.v
+      theorems: '*'
+    - path: backend/Unusedglobproof.v
+      theorems: '*'
+    - path: backend/Allocation.v
+      theorems: '*'
+    - path: backend/Constpropproof.v
+      theorems: '*'
+    - path: backend/Inliningproof.v
+      theorems: '*'
+    - path: backend/Bounds.v
+      theorems: '*'
+    - path: backend/Conventions.v
+      theorems: '*'
+    - path: backend/ValueAnalysis.v
+      theorems: '*'
+    - path: backend/Deadcode.v
+      theorems: '*'
+    - path: backend/ValueDomain.v
+      theorems: '*'
+    - path: backend/RTLgenspec.v
+      theorems: '*'
+    - path: backend/Asmgenproof0.v
+      theorems: '*'
+    - path: backend/RTL.v
+      theorems: '*'
+    - path: backend/RTLtyping.v
+      theorems: '*'
+    - path: backend/Tailcall.v
+      theorems: '*'
+    - path: backend/Tailcallproof.v
+      theorems: '*'
+    - path: backend/CSE.v
+      theorems: '*'
+    - path: backend/CleanupLabels.v
+      theorems: '*'
+    - path: backend/LTL.v
+      theorems: '*'
+    - path: backend/CminorSel.v
+      theorems: '*'
+    - path: backend/Constprop.v
+      theorems: '*'
+    - path: backend/CSEdomain.v
+      theorems: '*'
+    - path: backend/Tunnelingproof.v
+      theorems: '*'
+    - path: backend/Selection.v
+      theorems: '*'
+    - path: backend/Debugvarproof.v
+      theorems: '*'
+    - path: backend/NeedDomain.v
+      theorems: '*'
+    - path: backend/Liveness.v
+      theorems: '*'
+    - path: backend/Selectionproof.v
+      theorems: '*'
+    - path: backend/Locations.v
+      theorems: '*'
+    - path: backend/Inliningspec.v
+      theorems: '*'
+    - path: backend/RTLgen.v
+      theorems: '*'
+    - path: backend/Linearize.v
+      theorems: '*'
+    - path: backend/Kildall.v
+      theorems: '*'
+    - path: backend/Renumber.v
+      theorems: '*'
+    - path: backend/Renumberproof.v
+      theorems: '*'
+    - path: backend/Unusedglob.v
+      theorems: '*'
+    - path: backend/Tunneling.v
+      theorems: '*'
+    - path: backend/Lineartyping.v
+      theorems: '*'
+    - path: backend/SplitLong.v
+      theorems: '*'
+    - path: backend/Debugvar.v
+      theorems: '*'
+    - path: backend/Deadcodeproof.v
+      theorems: '*'
+    - path: backend/RTLgenproof.v
+      theorems: '*'
+    - path: backend/SplitLongproof.v
+      theorems: '*'
+    - path: backend/Linear.v
+      theorems: '*'
+    - path: lib/Integers.v
+      theorems: '*'
+    - path: lib/Axioms.v
+      theorems: '*'
+    - path: lib/Ordered.v
+      theorems: '*'
+    - path: lib/IntvSets.v
+      theorems: '*'
+    - path: lib/Floats.v
+      theorems: '*'
+    - path: lib/Decidableplus.v
+      theorems: '*'
+    - path: lib/IEEE754_extra.v
+      theorems: '*'
+    - path: lib/Intv.v
+      theorems: '*'
+    - path: lib/FSetAVLplus.v
+      theorems: '*'
+    - path: lib/Maps.v
+      theorems: '*'
+    - path: lib/Postorder.v
+      theorems: '*'
+    - path: lib/Coqlib.v
+      theorems: '*'
+    - path: lib/BoolEqual.v
+      theorems: '*'
+    - path: lib/Heaps.v
+      theorems: '*'
+    - path: lib/UnionFind.v
+      theorems: '*'
+    - path: lib/Zbits.v
+      theorems: '*'
+    - path: lib/Lattice.v
+      theorems: '*'
+    - path: lib/Wfsimpl.v
+      theorems: '*'
+    - path: lib/Iteration.v
+      theorems: '*'
+    - path: lib/Parmov.v
+      theorems: '*'
+    - path: cfrontend/Clight.v
+      theorems: '*'
+    - path: cfrontend/Csem.v
+      theorems: '*'
+    - path: cfrontend/Ctypes.v
+      theorems: '*'
+    - path: cfrontend/SimplExpr.v
+      theorems: '*'
+    - path: cfrontend/Cexec.v
+      theorems: '*'
+    - path: cfrontend/Cminorgenproof.v
+      theorems: '*'
+    - path: cfrontend/Initializers.v
+      theorems: '*'
+    - path: cfrontend/Cstrategy.v
+      theorems: '*'
+    - path: cfrontend/SimplExprproof.v
+      theorems: '*'
+    - path: cfrontend/Cshmgen.v
+      theorems: '*'
+    - path: cfrontend/Cminorgen.v
+      theorems: '*'
+    - path: cfrontend/Initializersproof.v
+      theorems: '*'
+    - path: cfrontend/SimplLocals.v
+      theorems: '*'
+    - path: cfrontend/ClightBigstep.v
+      theorems: '*'
+    - path: cfrontend/Cshmgenproof.v
+      theorems: '*'
+    - path: cfrontend/SimplExprspec.v
+      theorems: '*'
+    - path: cfrontend/Csharpminor.v
+      theorems: '*'
+    - path: cfrontend/Cop.v
+      theorems: '*'
+    - path: cfrontend/Ctyping.v
+      theorems: '*'
+    - path: cfrontend/SimplLocalsproof.v
+      theorems: '*'
+    - path: cfrontend/Csyntax.v
+      theorems: '*'
+    - path: x86_64/Archi.v
+      theorems: '*'
+    - path: common/AST.v
+      theorems: '*'
+    - path: common/Globalenvs.v
+      theorems: '*'
+    - path: common/Memtype.v
+      theorems: '*'
+    - path: common/Builtins0.v
+      theorems: '*'
+    - path: common/Separation.v
+      theorems: '*'
+    - path: common/Linking.v
+      theorems: '*'
+    - path: common/Determinism.v
+      theorems: '*'
+    - path: common/Smallstep.v
+      theorems: '*'
+    - path: common/Memory.v
+      theorems: '*'
+    - path: common/Events.v
+      theorems: '*'
+    - path: common/Errors.v
+      theorems: '*'
+    - path: common/Builtins.v
+      theorems: '*'
+    - path: common/Switch.v
+      theorems: '*'
+    - path: common/Unityping.v
+      theorems: '*'
+    - path: common/Memdata.v
+      theorems: '*'
+    - path: common/Values.v
+      theorems: '*'
+    - path: common/Behaviors.v
+      theorems: '*'
+    - path: cparser/Parser.v
+      theorems: '*'
+    - path: cparser/Cabs.v
+      theorems: '*'