itp-interface 1.0.0__py3-none-any.whl

itp_interface/rl/proof_action.py

@@ -0,0 +1,172 @@
+#!/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 typing
+from itp_interface.tools.coq_parse_utils import CoqLineByLineReader
+from itp_interface.tools.lean_parse_utils import LeanLineByLineReader
+from itp_interface.tools.isabelle_parse_utils import IsabelleLineByLineReader
+from itp_interface.rl.abstraction import Action
+from enum import Enum
+from dataclasses import dataclass, field
+from dataclasses_json import dataclass_json
+
+@dataclass_json
+@dataclass
+class ProofAction(Action):
+    class Language(Enum):
+        COQ = 'COQ'
+        LEAN = 'LEAN'
+        LEAN4 = 'LEAN4'
+        ISABELLE = 'ISABELLE'
+
+        def __str__(self):
+            return self.name
+
+    class ActionType(Enum):
+        GET_DFNS_THMS = 'GET_DFNS_THMS'
+        RUN_TACTIC = 'RUN_TACTIC'
+        BACKTRACK = 'BACKTRACK'
+        EXIT = 'EXIT'
+        NONE = 'NONE'
+
+        @staticmethod
+        def get_order(action_type: 'ProofAction.ActionType'):
+            if action_type == ProofAction.ActionType.EXIT:
+                return 7
+            elif action_type == ProofAction.ActionType.BACKTRACK:
+                return 6
+            elif action_type == ProofAction.ActionType.NONE:
+                return 5
+            if action_type == ProofAction.ActionType.RUN_TACTIC:
+                return 4
+            elif action_type == ProofAction.ActionType.GET_DFNS_THMS:
+                return 3
+            else:
+                return 0
+
+        def __str__(self):
+            return self.name
+        
+        def __lt__(self, other):
+            assert isinstance(other, ProofAction.ActionType), f"other must be of type ProofAction.ActionType, not {type(other)}"
+            return ProofAction.ActionType.get_order(self) < ProofAction.ActionType.get_order(other)
+        
+        def __le__(self, other):
+            assert isinstance(other, ProofAction.ActionType), f"other must be of type ProofAction.ActionType, not {type(other)}"
+            return ProofAction.ActionType.get_order(self) <= ProofAction.ActionType.get_order(other)
+        
+        def __gt__(self, other):
+            assert isinstance(other, ProofAction.ActionType), f"other must be of type ProofAction.ActionType, not {type(other)}"
+            return ProofAction.ActionType.get_order(self) > ProofAction.ActionType.get_order(other)
+        
+        def __ge__(self, other):
+            assert isinstance(other, ProofAction.ActionType), f"other must be of type ProofAction.ActionType, not {type(other)}"
+            return ProofAction.ActionType.get_order(self) >= ProofAction.ActionType.get_order(other)
+
+    action_type: ActionType
+    language: Language
+    kwargs: typing.Optional[dict] = field(default_factory=dict)
+    def __init__(self, action_type: ActionType, language: Language, **kwargs):
+        assert isinstance(action_type, ProofAction.ActionType), f"action_type must be of type ProofAction.Type, not {type(action_type)}"
+        self.action_type = action_type
+        self.language = language
+        if kwargs is not None and isinstance(kwargs, dict) and len(kwargs) == 1 and "kwargs" in kwargs:
+            kwargs = kwargs["kwargs"] # TODO: this is a hack to get around the fact that dataclasses_json doesn't support having parameterized fields in the constructor
+        self.kwargs = kwargs
+        if self.action_type == ProofAction.ActionType.RUN_TACTIC:
+            assert "tactics" in self.kwargs, f"kwargs must contain a 'tactic' key for action_type {self.action_type}"
+            assert isinstance(self.kwargs["tactics"], list), f"kwargs['tactics'] must be of type str, not {type(self.kwargs['tactics'])}"
+            assert len(self.kwargs["tactics"]) > 0, f"kwargs['tactics'] must be a non-empty list"
+            for tactic in self.kwargs["tactics"]:
+                assert isinstance(tactic, str), f"kwargs['tactics'] must be of type str, not {type(tactic)}"
+        else:
+            assert len(self.kwargs) == 0, f"kwargs must be empty for action_type {self.action_type}"
+        self._post_init()
+    
+    def _post_init(self):
+        type = self.action_type
+        if type == ProofAction.ActionType.RUN_TACTIC:
+            if self.language == ProofAction.Language.COQ:
+                all_tactics = '\n'.join(self.kwargs['tactics'])
+                reader = CoqLineByLineReader(file_content=all_tactics)
+                tactics = list(reader.instruction_step_generator())
+                self.kwargs['tactics'] = tactics
+            elif self.language == ProofAction.Language.LEAN:
+                all_tactics = '\n'.join(self.kwargs['tactics'])
+                # reader = LeanLineByLineReader(file_content=all_tactics)
+                tactics = [all_tactics]
+                self.kwargs['tactics'] = tactics
+            elif self.language == ProofAction.Language.LEAN4:
+                all_tactics = '\n'.join(self.kwargs['tactics'])
+                # reader = LeanLineByLineReader(file_content=all_tactics)
+                tactics = [all_tactics]
+                self.kwargs['tactics'] = tactics
+            elif self.language == ProofAction.Language.ISABELLE:
+                all_tactics = '\n'.join(self.kwargs['tactics'])
+                # reader = IsabelleLineByLineReader(file_content=all_tactics)
+                tactics = [all_tactics]
+                self.kwargs['tactics'] = tactics
+        self.original_message : typing.Any = None
+        pass
+
+    @property
+    def name(self):
+        return f"{self.action_type.name} | {self.kwargs}"
+    
+    def __eq__(self, other):
+        if not isinstance(other, ProofAction):
+            return False
+        if self.action_type != other.action_type:
+            return False
+        if self.action_type == ProofAction.ActionType.RUN_TACTIC:
+            tactics = self.kwargs['tactics']
+            other_tactics = other.kwargs['tactics']
+            if len(tactics) != len(other_tactics):
+                return False
+            for i in range(len(tactics)):
+                if tactics[i] != other_tactics[i]:
+                    return False
+        return True
+    
+    def __hash__(self):
+        if self.action_type != ProofAction.ActionType.RUN_TACTIC:
+            return hash(self.action_type)
+        else:
+            tactics = self.kwargs['tactics']
+            return hash((self.action_type, tuple(tactics)))
+
+    def __ge__(self, other):
+        if not isinstance(other, ProofAction):
+            return False
+        return self.action_type >= other.action_type
+
+    def __gt__(self, other):
+        if not isinstance(other, ProofAction):
+            return False
+        return self.action_type > other.action_type
+    
+    def __le__(self, other):
+        if not isinstance(other, ProofAction):
+            return False
+        return self.action_type <= other.action_type
+    
+    def __lt__(self, other):
+        if not isinstance(other, ProofAction):
+            return False
+        return self.action_type < other.action_type
+
+    def __call__(self):
+        pass
+
+    def serialize(self) -> str:
+        return self.to_json()
+
+if __name__ == "__main__":
+    action = ProofAction(action_type=ProofAction.ActionType.RUN_TACTIC, tactics=["intros.", "reflexivity."])
+    print(action.serialize())
+    action1 = ProofAction.schema().loads(action.serialize())
+    assert action == action1

itp_interface/rl/proof_state.py

@@ -0,0 +1,149 @@
+#!/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 typing
+from itp_interface.tools.dynamic_coq_proof_exec import DynamicProofExecutor as DynamicCoqProofExecutor
+from itp_interface.tools.dynamic_lean_proof_exec import DynamicProofExecutor as DynamicLeanProofExecutor
+from itp_interface.tools.dynamic_lean4_proof_exec import DynamicProofExecutor as DynamicLean4ProofExecutor
+from itp_interface.tools.dynamic_isabelle_proof_exec import DynamicProofExecutor as DynamicIsabelleProofExecutor
+from itp_interface.rl.abstraction import State
+from itp_interface.rl.proof_action import ProofAction
+from itp_interface.tools.training_data_format import TrainingDataFormat
+from dataclasses_json import dataclass_json
+from dataclasses import dataclass
+
+@dataclass_json
+@dataclass
+class ProofState(State):
+    training_data_format: TrainingDataFormat
+    was_reset: bool = False
+    language: ProofAction.Language = ProofAction.Language.COQ
+    theorem_statement_with_name: typing.Optional[str] = None
+    theorem_name: typing.Optional[str] = None
+
+    def _post_init(self):
+        self.proof_tree = None
+
+    @property
+    def name(self):
+        return f"{self.training_data_format.start_goals}"[:25]
+
+    def __eq__(self, other):
+        if not isinstance(other, ProofState):
+            return False
+        assert self.language == other.language, f"self.language: {self.language}, other.language: {other.language}"
+        if self.training_data_format is None or other.training_data_format is None:
+            return self.training_data_format == other.training_data_format
+        if self.language == ProofAction.Language.COQ:
+            desc_cmp = DynamicCoqProofExecutor.goal_description_compare(self.training_data_format.goal_description, other.training_data_format.goal_description)
+        elif self.language == ProofAction.Language.LEAN:
+            desc_cmp = DynamicLeanProofExecutor.goal_description_compare(self.training_data_format.goal_description, other.training_data_format.goal_description)
+        elif self.language == ProofAction.Language.LEAN4:
+            desc_cmp = DynamicLean4ProofExecutor.goal_description_compare(self.training_data_format.goal_description, other.training_data_format.goal_description)
+        elif self.language == ProofAction.Language.ISABELLE:
+            desc_cmp = DynamicIsabelleProofExecutor.goal_description_compare(self.training_data_format.goal_description, other.training_data_format.goal_description)
+        else:
+            raise NotImplementedError(f"language {self.language} not supported")
+        if desc_cmp == 0:
+            return self.training_data_format == other.training_data_format
+        else:
+            return False
+
+    def __hash__(self):
+        return hash(self.training_data_format)
+
+    def serialize(self) -> str:
+        serialized_json = self.to_json()
+        return serialized_json
+    
+    def __ge__(self, __o: object) -> bool:
+        assert isinstance(__o, ProofState)
+        assert self.language == __o.language, f"self.language: {self.language}, __o.language: {__o.language}"
+        if self.language == ProofAction.Language.COQ:
+            FailedProofState = FailedCoqProofState
+        elif self.language == ProofAction.Language.LEAN:
+            FailedProofState = FailedLeanProofState
+        elif self.language == ProofAction.Language.LEAN4:
+            FailedProofState = FailedLean4ProofState
+        elif self.language == ProofAction.Language.ISABELLE:
+            FailedProofState = FailedIsabelleProofState
+
+        if __o == FailedProofState: # FailedProofState is the hardest state to reach
+            return self.training_data_format == __o.training_data_format
+        if self == FailedProofState:
+            return True
+        assert isinstance(self.training_data_format, TrainingDataFormat)
+        if self.language == ProofAction.Language.COQ:
+            desc_cmp = DynamicCoqProofExecutor.goal_description_compare(self.training_data_format.goal_description, __o.training_data_format.goal_description)
+        elif self.language == ProofAction.Language.LEAN:
+            desc_cmp = DynamicLeanProofExecutor.goal_description_compare(self.training_data_format.goal_description, __o.training_data_format.goal_description)
+        elif self.language == ProofAction.Language.LEAN4:
+            desc_cmp = DynamicLean4ProofExecutor.goal_description_compare(self.training_data_format.goal_description, __o.training_data_format.goal_description)
+        elif self.language == ProofAction.Language.ISABELLE:
+            desc_cmp = DynamicIsabelleProofExecutor.goal_description_compare(self.training_data_format.goal_description, __o.training_data_format.goal_description)
+        else:
+            raise NotImplementedError(f"language {self.language} not supported")
+        if desc_cmp == 0:
+            return self.training_data_format >= __o.training_data_format
+        else:
+            return desc_cmp < 0
+
+    def __le__(self, __o: object) -> bool:
+        assert isinstance(__o, ProofState)
+        assert self.language == __o.language, f"self.language: {self.language}, __o.language: {__o.language}"
+
+        if self.language == ProofAction.Language.COQ:
+            FailedProofState = FailedCoqProofState
+        elif self.language == ProofAction.Language.LEAN:
+            FailedProofState = FailedLeanProofState
+        elif self.language == ProofAction.Language.LEAN4:
+            FailedProofState = FailedLean4ProofState
+        elif self.language == ProofAction.Language.ISABELLE:
+            FailedProofState = FailedIsabelleProofState
+
+        if self == FailedProofState: # FailedProofState is the hardest state to reach
+            return self.training_data_format == __o.training_data_format
+        if __o == FailedProofState:
+            return True
+        assert isinstance(self.training_data_format, TrainingDataFormat)
+        if self.language == ProofAction.Language.COQ:
+            desc_cmp = DynamicCoqProofExecutor.goal_description_compare(self.training_data_format.goal_description, __o.training_data_format.goal_description)
+        elif self.language == ProofAction.Language.LEAN:
+            desc_cmp = DynamicLeanProofExecutor.goal_description_compare(self.training_data_format.goal_description, __o.training_data_format.goal_description)
+        elif self.language == ProofAction.Language.LEAN4:
+            desc_cmp = DynamicLean4ProofExecutor.goal_description_compare(self.training_data_format.goal_description, __o.training_data_format.goal_description)
+        elif self.language == ProofAction.Language.ISABELLE:
+            desc_cmp = DynamicIsabelleProofExecutor.goal_description_compare(self.training_data_format.goal_description, __o.training_data_format.goal_description)
+        else:
+            raise NotImplementedError(f"language {self.language} not supported")
+        if desc_cmp == 0:
+            return self.training_data_format <= __o.training_data_format
+        else:
+            return desc_cmp > 0
+    
+    def __lt__(self, __o: object) -> bool:
+        assert isinstance(__o, ProofState)
+        assert isinstance(self.training_data_format, TrainingDataFormat)
+        assert self.language == __o.language, f"self.language: {self.language}, __o.language: {__o.language}"
+        return self.training_data_format != __o.training_data_format and self.training_data_format <= __o.training_data_format
+    
+    def __gt__(self, __o: object) -> bool:
+        assert isinstance(__o, ProofState)
+        assert isinstance(self.training_data_format, TrainingDataFormat)
+        assert self.language == __o.language, f"self.language: {self.language}, __o.language: {__o.language}"
+        return self.training_data_format != __o.training_data_format and self.training_data_format >= __o.training_data_format
+
+
+FailedCoqProofState = ProofState(training_data_format=None, language=ProofAction.Language.COQ)
+FailedLeanProofState = ProofState(training_data_format=None, language=ProofAction.Language.LEAN)
+FailedLean4ProofState = ProofState(training_data_format=None, language=ProofAction.Language.LEAN4)
+FailedIsabelleProofState = ProofState(training_data_format=None, language=ProofAction.Language.ISABELLE)
+
+if __name__ == "__main__":
+    proof_state = ProofState(training_data_format=None)
+    print(proof_state.serialize())
+    pass

itp_interface/rl/proof_tree.py

@@ -0,0 +1,109 @@
+#!/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 typing
+from dataclasses_json import dataclass_json
+from dataclasses import dataclass, field
+from itp_interface.rl.proof_action import ProofAction
+from itp_interface.tools.training_data_format import TrainingDataFormat
+
+@dataclass_json
+@dataclass
+class ProofTree(object):
+    tactics: typing.List[typing.Tuple[int, TrainingDataFormat]] = field(default_factory=list)
+    actions: typing.List[typing.Optional[ProofAction]] = field(default_factory=list)
+
+    def __len__(self):
+        return len(self.tactics)
+
+    def __getitem__(self, index):
+        return self.tactics[index]
+
+    def try_add_tactic(self, line_num, tactic: TrainingDataFormat, force_add: bool = False, action: ProofAction = None):
+        # Make sure that the tactic is not more hard than any of the previous tactics
+        if not force_add:
+            for _, prev_tactic in self.tactics:
+                if tactic >= prev_tactic: # New tactic should be easier than all the previous tactics
+                    return False
+        self.tactics.append((line_num, tactic))
+        self.actions.append(action)
+        return True
+
+    def try_remove_last_tactic(self):
+        if len(self.tactics) > 0:
+            line_num, tactic = self.tactics.pop()
+            self.actions.pop()
+            return line_num, tactic
+        return None, None
+
+    def _convert_to_str(self, tactic: TrainingDataFormat) -> typing.Tuple[str, list, list]:
+        # sort the goals
+        goal_set = set([goal.goal for goal in tactic.start_goals])
+        hyp_set = set([hyp for goal in tactic.start_goals for hyp in goal.hypotheses])
+        goals = sorted(goal_set)
+        hyps = sorted(hyp_set)
+        goal_str = "\n".join(goals)
+        return goal_str, goals, hyps
+
+@dataclass_json
+@dataclass
+class ProofSearchResult(object):
+    proof_file: typing.Optional[str]
+    proof_found: bool
+    lemma_name: str
+    proof_steps: typing.List[TrainingDataFormat]
+    proof_time_in_secs: float
+    inferences_taken: int
+    possible_failed_paths: int
+    num_of_backtracks: int
+    is_timeout: bool
+    is_inference_exhausted: bool
+    longest_success_path: int
+    additional_info: typing.Dict[str, typing.Any] = field(default_factory=dict)
+    language: ProofAction.Language = ProofAction.Language.COQ
+
+    def __str__(self) -> str:
+        try:
+            lines = [line for step in self.proof_steps for line in step.proof_steps]
+            proof_metadata = f"""
+ProofFile: {self.proof_file}
+LemmaName: {self.lemma_name}
+SearchResult: {'[FAILED]' if not self.proof_found else '[SUCCESS]'}
+IsInferenceExhausted: {self.is_inference_exhausted}
+IsTimeout: {self.is_timeout}
+LongestSuccessPath: {self.longest_success_path} 
+StepsUsed: {self.inferences_taken}
+SearchTimeInSecs: {self.proof_time_in_secs}
+NumberOfBacktracks: {self.num_of_backtracks}
+PossibleFailedPaths: {self.possible_failed_paths}
+AdditionalInfo: {self.additional_info}
+"""
+            if self.language == ProofAction.Language.ISABELLE:
+                all_proof_steps = "\n".join(lines) if len(lines) > 0 else ""
+                return f"""{self.lemma_name}
+{all_proof_steps}
+{proof_metadata}
+"""
+            elif self.language == ProofAction.Language.COQ:
+                proof_start = "Proof."
+                proof_end = "Qed."
+            elif self.language == ProofAction.Language.LEAN:
+                proof_start = "begin"
+                proof_end = "end"
+            elif self.language == ProofAction.Language.LEAN4:
+                proof_start = ""
+                proof_end = ""
+            all_proof_steps = "\n    ".join(lines[:-1]) if len(lines) > 1 else ""
+            last_line = (lines[-1] if lines[-1] == proof_end else f"    {lines[-1]}\n") if len(lines) > 0 else ""
+            return f"""{self.lemma_name}
+{proof_start}
+    {all_proof_steps}
+{last_line}
+{proof_metadata}
+"""
+        except Exception:
+            return f"------- UNABLE_TO_PRINT_INCOMPLETE_PROOF ----------"

itp_interface/rl/simpl_proof_env_pool.py

@@ -0,0 +1,16 @@
+#!/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)
+# This is a hack to fix the wrong file name in the import statement of other files
+# This will be deprecated once all dependencies are moved to simple_proof_env_pool.py vs simpl_proof_env_pool.py
+# Let's add deprecation warning here
+import warnings
+warnings.warn("simpl_proof_env_pool.py is deprecated. Use simple_proof_env_pool.py instead.", DeprecationWarning)
+from itp_interface.rl.simple_proof_env_pool import (
+    ProofEnv, ProofEnvActor, ProofEnvInfo, ProofEnvReRankStrategy, ProofExecutorCallback,
+    IsabelleExecutor, HammerMode, ProofAction, ProofState, 
+    replicate_proof_env, CapturedException, CaptureExceptionActor, ProofEnvPool
+)