itp-interface 1.3.0__tar.gz → 1.5.0__tar.gz

{itp_interface-1.3.0 → itp_interface-1.5.0}/.github/workflows/github-build-actions-python314t.yaml

@@ -26,17 +26,21 @@ jobs:
         run: |
           apt-get update
           apt-get install -y wget
+          apt-get clean
+          rm -rf /var/lib/apt/lists/*
           wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/miniconda.sh
           bash /tmp/miniconda.sh -b -p $HOME/miniconda
-          rm /tmp/miniconda.sh
+          rm -f /tmp/miniconda.sh
           export PATH="$HOME/miniconda/bin:$PATH"
           conda init bash
+          conda clean -all -y
 
       - name: Create Python 3.14 free-threading conda environment
         shell: bash
         run: |
           export PATH="$HOME/miniconda/bin:$PATH"
           conda create -n py314-ft python=3.14 python-freethreading -c conda-forge -y
+          conda clean -all -y
 
       - name: Check Python version and GIL status
         shell: bash
@@ -53,6 +57,7 @@ jobs:
           source $HOME/miniconda/bin/activate py314-ft
           python -m pip install --upgrade pip
           pip install build==1.3.0 hatchling==1.27.0
+          pip cache purge
 
       - name: Build package with hatchling
         shell: bash
@@ -67,6 +72,9 @@ jobs:
           export PATH="$HOME/miniconda/bin:$PATH"
           source $HOME/miniconda/bin/activate py314-ft
           pip install dist/*.whl
+          # Clean up build artifacts and pip cache
+          rm -rf build/ dist/ *.egg-info
+          pip cache purge
 
       - name: Install Lean (elan) and prepare Lean REPL
         shell: bash
@@ -84,6 +92,30 @@ jobs:
           source $HOME/.elan/env
           install-itp-interface
 
+      - name: Free up disk space before Lean build
+        shell: bash
+        run: |
+          echo "Disk space before cleanup:"
+          df -h
+          # Clean conda caches again
+          export PATH="$HOME/miniconda/bin:$PATH"
+          conda clean -all -y
+          # Clean pip cache
+          pip cache purge || true
+          # Clean apt cache
+          apt-get clean
+          rm -rf /var/lib/apt/lists/*
+          # Clean tmp directory
+          rm -rf /tmp/* 2>/dev/null || true
+          # Clean any build artifacts
+          rm -rf build/ dist/ *.egg-info 2>/dev/null || true
+          # Clean logs
+          rm -rf .log 2>/dev/null || true
+          # Clean GitHub runner logs if accessible
+          rm -rf /home/runner/actions-runner/cached/_diag/*.log 2>/dev/null || true
+          echo "Disk space after cleanup:"
+          df -h
+
       - name: Build lean4_proj
         shell: bash
         run: |

{itp_interface-1.3.0 → itp_interface-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itp_interface
-Version: 1.3.0
+Version: 1.5.0
 Summary: Generic interface for hooking up to any Interactive Theorem Prover (ITP) and collecting data for training ML models for AI in formal theorem proving.
 Project-URL: Homepage, https://github.com/trishullab/itp-interface
 Project-URL: Issues, https://github.com/trishullab/itp-interface/issues

{itp_interface-1.3.0 → itp_interface-1.5.0}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [
 build-backend = "hatchling.build"
 [project]
 name = "itp_interface"
-version = "1.3.0"
+version = "1.5.0"
 authors = [
   { name="Amitayush Thakur", email="amitayush@utexas.edu" },
 ]

{itp_interface-1.3.0 → itp_interface-1.5.0}/src/itp_interface/agent/simple_proof_agent.py

@@ -80,7 +80,8 @@ class ProofAgent(Agent):
                     self.logger.info("**"*20)
                     env.render()
                     self.logger.info("**"*20)
-                if action.action_type != ProofAction.ActionType.BACKTRACK:
+                if action.action_type != ProofAction.ActionType.BACKTRACK and \
+                    action.action_type != ProofAction.ActionType.FULL_BACKTRACK:
                     # Don't update policy for backtracking actions, this will create a 
                     # a very nasty loop in the policy.
                     self.logger.info("Updating policy")

{itp_interface-1.3.0 → itp_interface-1.5.0}/src/itp_interface/lean/lean4_local_data_extraction_transform.py

@@ -12,7 +12,7 @@ import json
 from pathlib import Path
 from filelock import FileLock
 from itp_interface.lean.simple_lean4_sync_executor import SimpleLean4SyncExecutor
-from itp_interface.lean.parsing_helpers import LeanDeclParser, LeanParseResult, LeanDeclType
+from itp_interface.lean.parsing_helpers import LeanDeclType, preprocess_declarations
 from itp_interface.tools.coq_training_data_generator import GenericTrainingDataGenerationTransform, TrainingDataGenerationType
 from itp_interface.tools.training_data_format import MergableCollection, TrainingDataMetadataFormat, ExtractionDataCollection
 from itp_interface.tools.training_data import TrainingData, DataLayoutFormat
@@ -192,38 +192,7 @@ class Local4DataExtractionTransform(GenericTrainingDataGenerationTransform):
         project_path: str,
         file_dep_analyses: typing.List[FileDependencyAnalysis]) -> None:
         # Preprocess declarations to set file paths and module names
-        for fda in file_dep_analyses:
-            for decl in fda.declarations:
-                self._preprocess_declaration(project_path, decl)
-    
-    def _preprocess_declaration(
-        self,
-        project_path: str,
-        decl: DeclWithDependencies) -> None:
-        # Filter all unknown types
-        if decl.decl_info.decl_type == LeanDeclType.UNKNOWN.value:
-            # Check if we have docstring or not
-            if decl.decl_info.doc_string is None or decl.decl_info.doc_string.strip() != "":
-                parser = LeanDeclParser(decl.decl_info.text)
-                parse_result = parser.parse()
-                if parse_result.doc_string is not None:
-                    decl.decl_info.doc_string = parse_result.doc_string.strip()
-                if parse_result.decl_type != LeanDeclType.UNKNOWN:
-                    decl.decl_info.decl_type = str(parse_result.decl_type)
-                if parse_result.text is not None:
-                    full_text = []
-                    if parse_result.text_before is not None:
-                        full_text.append(parse_result.text_before.strip())
-                    full_text.append(parse_result.text.strip())
-                    text = "\n".join(full_text)
-                    decl.decl_info.text = text
-                # Update the proof if not already present
-                if decl.decl_info.proof is None and parse_result.proof is not None:
-                    decl.decl_info.proof = parse_result.proof.strip()
-                if parse_result.name is not None:
-                    decl.decl_info.name = parse_result.name.strip()
-        pass
-
+        preprocess_declarations(file_dep_analyses)
 
     def __call__(self,
         training_data: TrainingData,

{itp_interface-1.3.0 → itp_interface-1.5.0}/src/itp_interface/lean/parsing_helpers.py

@@ -1,8 +1,7 @@
-import sys
-import re
 from enum import Enum
 from dataclasses import dataclass
-from typing import Optional, Set
+from typing import Optional
+from itp_interface.lean.tactic_parser import DeclWithDependencies, FileDependencyAnalysis
 
 class LeanDeclType(Enum):
     LEMMA = "lemma"
@@ -373,4 +372,36 @@ class LeanDeclParser:
 
 def parse_lean_text(text: str) -> LeanParseResult:
     parser = LeanDeclParser(text)
-    return parser.parse()
+    return parser.parse()
+
+def preprocess_declarations(
+    file_dep_analyses: list[FileDependencyAnalysis]) -> None:
+    # Preprocess declarations to set file paths and module names
+    for fda in file_dep_analyses:
+        for decl in fda.declarations:
+            preprocess_declaration(decl)
+
+def preprocess_declaration(
+    decl: DeclWithDependencies) -> None:
+    # Filter all unknown types
+    if decl.decl_info.decl_type == LeanDeclType.UNKNOWN.value:
+        # Check if we have docstring or not
+        if decl.decl_info.doc_string is None or decl.decl_info.doc_string.strip() != "":
+            parser = LeanDeclParser(decl.decl_info.text)
+            parse_result = parser.parse()
+            if parse_result.doc_string is not None:
+                decl.decl_info.doc_string = parse_result.doc_string.strip()
+            if parse_result.decl_type != LeanDeclType.UNKNOWN:
+                decl.decl_info.decl_type = str(parse_result.decl_type)
+            if parse_result.text is not None:
+                full_text = []
+                if parse_result.text_before is not None:
+                    full_text.append(parse_result.text_before.strip())
+                full_text.append(parse_result.text.strip())
+                text = "\n".join(full_text)
+                decl.decl_info.text = text
+            # Update the proof if not already present
+            if decl.decl_info.proof is None and parse_result.proof is not None:
+                decl.decl_info.proof = parse_result.proof.strip()
+            if parse_result.name is not None:
+                decl.decl_info.name = parse_result.name.strip()

{itp_interface-1.3.0 → itp_interface-1.5.0}/src/itp_interface/lean/simple_lean4_sync_executor.py

@@ -1,6 +1,8 @@
 #!/usr/bin/env python3
 
+from contextlib import nullcontext
 import os
+import base64
 import copy
 import random
 import logging
@@ -10,6 +12,7 @@ import json
 import typing
 import bisect
 import subprocess
+from filelock import FileLock
 from itp_interface.lean.tactic_parser import (
     TacticParser, 
     ErrorInfo, 
@@ -25,12 +28,18 @@ from itp_interface.tools.theorem_details import TheoremDetails
 from itp_interface.tools.misc_defns import HammerMode
 from itp_interface.tools.iter_helpers import ClonableIterator
 from typing import List, Optional, Tuple, OrderedDict, Dict
+from tempfile import gettempdir, NamedTemporaryFile
+from itp_interface.lean.parsing_helpers import preprocess_declarations
 
 class SimpleLean4SyncExecutor:
     theorem_regex = r"((((theorem|lemma)[\s]+([^\s:]*))|example)([\S|\s]*?)(:=|=>)[\s]*?)[\s]+"
     theorem_match = re.compile(theorem_regex, re.MULTILINE)
+    theorem_has_by = r"^[\s]*:=[\s]*by[\s]*"
     have_regex = r"(^\s*have\s+([^:]*):([\s|\S]*?))(:=\s*by)([\s|\S]*)"
     have_match = re.compile(have_regex, re.MULTILINE)
+    theorem_has_by_match = re.compile(theorem_has_by, re.MULTILINE)
+    ends_with_by_sorry = r":=[\s]*by\s+sorry[\s]*$"
+    ends_with_by_sorry_match = re.compile(ends_with_by_sorry, re.MULTILINE)
     unsolved_message = "unsolved goals"
     no_goals = "No goals to be solved"
     no_goals_alternative = "no goals to be solved"
@@ -51,7 +60,8 @@ class SimpleLean4SyncExecutor:
         enable_search: bool = False,
         keep_local_context: bool = False,
         enforce_qed: bool = False,
-        logger: Optional[logging.Logger] = None):
+        logger: Optional[logging.Logger] = None,
+        starting_tactic_sequence: Optional[List[str]] = None):
         assert proof_step_iter is None or isinstance(proof_step_iter, ClonableIterator), \
             "proof_step_iter must be an iterator"
         assert main_file is not None or proof_step_iter is not None, \
@@ -116,6 +126,7 @@ class SimpleLean4SyncExecutor:
         self._last_modified_tactic : str | None = None
         self._recursion_depth = 0
         self.max_threshold_for_tactic_length = 575 # Max 575 characters for a tactic
+        self._starting_tactic_sequence = ['by'] if starting_tactic_sequence is None or len(starting_tactic_sequence) == 0 else starting_tactic_sequence
         if self._enable_search:
             pass
         pass
@@ -176,7 +187,7 @@ class SimpleLean4SyncExecutor:
         self.tactic_parser = TacticParser(project_path=self.project_root, logger=self.logger)
         if self.main_file_iter is None:
             assert self.main_file is not None, "main_file must be set if main_file_iter is None"
-            self.main_file_iter = LeanLineByLineReader(self.main_file, remove_comments=True, no_strip=True).instruction_step_generator()
+            self.main_file_iter = LeanLineByLineReader(self.main_file, remove_comments=False, no_strip=True).instruction_step_generator()
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
@@ -185,6 +196,9 @@ class SimpleLean4SyncExecutor:
         if os.path.exists(self.temp_file_full_path):
             os.remove(self.temp_file_full_path)
 
+    def associated_file(self) -> str|None:
+        return self.main_file
+
     def is_in_proof_mode(self):
         return True if self.proof_context else (len(self.lean_error_messages) > 0) # It is still in proof mode if we encountered a wrong proof
 
@@ -217,13 +231,15 @@ class SimpleLean4SyncExecutor:
             self._lines_executed.append("") # Add an empty line to keep the line numbers in sync
         return True
 
-    def extract_all_theorems_and_definitions(self, json_output_path: str|None = None) -> List[FileDependencyAnalysis]:
-        assert self.main_file is not None, "main_file must be set to extract theorems and definitions"
+    def extract_all_theorems_and_definitions(self, json_output_path: str|None = None, file_path: str|None = None) -> List[FileDependencyAnalysis]:
         assert self.tactic_parser is not None, "tactic_parser must be initialized to extract theorems and definitions"
 
-        json_output_path = json_output_path if json_output_path is not None else self.main_file + ".dependency_analysis.json"
+        file_path = file_path if file_path is not None else self.main_file
+        assert file_path is not None, "Either file_path or main_file must be provided to extract theorems and definitions"
+        assert os.path.exists(file_path), f"file_path must exist to extract theorems and definitions ({file_path})"
+        json_output_path = json_output_path if json_output_path is not None else file_path + ".dependency_analysis.json"
         file_dependency_analysis, _ = self.tactic_parser.parse_file(
-            self.main_file,
+            file_path,
             parse_type=RequestType.PARSE_DEPENDS,
             json_output_path=json_output_path)
         return file_dependency_analysis
@@ -281,14 +297,20 @@ class SimpleLean4SyncExecutor:
             stmt = (" " * (indentation_needed - actual_indent)) + stmt.lstrip()
         return stmt
 
-    def _get_lean_code_with_tactics(self, idx: int, stmt: str):
+    def pretty_print_proof_so_far(self) -> str:
         assert self._last_theorem is not None, "Last theorem should not be None"
-        self._add_last_tactic(idx, stmt)
         tactics_so_far = self._get_tactics_so_far()
+        if len(tactics_so_far) == 0:
+            tactics_so_far = self.possible_proof_tactics
         assert len(tactics_so_far) > 0, "There should be at least one tactic so far"
         _ , _, theorem_stmt = self._last_theorem
         return theorem_stmt + "\n" + tactics_so_far + "\n"
 
+    def _get_lean_code_with_tactics(self, idx: int, stmt: str):
+        assert self._last_theorem is not None, "Last theorem should not be None"
+        self._add_last_tactic(idx, stmt)
+        return self.pretty_print_proof_so_far()
+
     def _backtrack_tactic_line(self, idx: int):
         # identify the keys to remove
         self._lines_executed = self._lines_executed[:idx]
@@ -589,20 +611,63 @@ class SimpleLean4SyncExecutor:
         lines : list[str] = []
         assert self.main_file_iter is not None, "main_file_iter should not be None"
         assert self.tactic_parser is not None, "Tactic parser is not initialized"
-        while True:
-            try:
-                stmt = next(self.main_file_iter)
-            except StopIteration:
-                break
-            lines.append(stmt)
-        full_file = "\n".join(lines) + "\n"
+        extraction_path = self._get_file_path_in_cache()
+        lock_file_path = self._get_lock_file_path_in_cache(extraction_path) if extraction_path is not None else None
+        # Use FileLock otherwise just a pass-through context manager
+        lock = FileLock(lock_file_path, timeout=self.timeout_in_sec*10) if lock_file_path is not None else nullcontext()
+        can_fetch_from_cache = extraction_path is not None
+        file_dep_analysis = None
+        with lock:
+            if can_fetch_from_cache:
+                file_path = self.associated_file()
+                assert file_path is not None, "File path should not be None"
+                if os.path.exists(extraction_path):
+                    temp_extraction_path_file = open(extraction_path, "r", encoding="utf-8")
+                    file_dep_analysis_str = temp_extraction_path_file.read()
+                    file_dep_analysis = [FileDependencyAnalysis.load_from_string(file_dep_analysis_str)]
+                else:
+                    file_dep_analysis = self.extract_all_theorems_and_definitions(
+                        json_output_path=extraction_path, file_path=file_path)
+                    assert file_dep_analysis is not None, "File dependency analysis should not be None"
+                    assert len(file_dep_analysis) > 0, "File dependency analysis should not be empty"
+                    
+                    temp_extraction_path_file = open(extraction_path, "w", encoding="utf-8")
+                    with temp_extraction_path_file:
+                        temp_extraction_path_file.write(file_dep_analysis[0].to_json())
+                with open(file_path, "r", encoding="utf-8") as f:
+                    lines = f.readlines()
+            else:
+                while True:
+                    try:
+                        stmt = next(self.main_file_iter)
+                    except StopIteration:
+                        break
+                    lines.append(stmt)
+                full_file = "\n".join(lines) + "\n"
+                # Dump the file in the temp file
+                with open(self.temp_file_full_path, "w", encoding="utf-8") as f:
+                    f.write(full_file)
+                file_path = self.temp_file_full_path
+                temp_extraction_path_file = NamedTemporaryFile(
+                    prefix="lean4_dep_analysis_",
+                    suffix=".json",
+                    delete_on_close=True)
+                extraction_path = temp_extraction_path_file.name
+                file_dep_analysis = self.extract_all_theorems_and_definitions(
+                    json_output_path=extraction_path, file_path=file_path)
+                temp_extraction_path_file.close()
+                # Remove the temp file
+                if os.path.exists(self.temp_file_full_path):
+                    os.remove(self.temp_file_full_path)
+        assert file_dep_analysis is not None, "File dependency analysis should not be None"
+        assert len(file_dep_analysis) > 0, "File dependency analysis should not be empty"
+        preprocess_declarations(file_dep_analysis)
+        file_dep_analysis = file_dep_analysis[0]
         # run the tactic parser in theorem parsing mode
-        lean_line_infos, _ = self.tactic_parser.parse(
-            full_file, 
-            fail_on_error=False, 
-            parse_type=RequestType.PARSE_THEOREM)
         # Filter out theorems and lemmas
-        theorems = [info for info in lean_line_infos if info.decl_type == "theorem" or info.decl_type == "lemma"]
+
+        theorems = [decl.decl_info for decl in file_dep_analysis.declarations
+                    if decl.decl_info.decl_type == "theorem" or decl.decl_info.decl_type == "lemma"]
         found_theorem = False
         for thm in theorems:
             name = thm.name
@@ -620,41 +685,38 @@ class SimpleLean4SyncExecutor:
         self._lines_executed = lines[:line_num - 1]
         theorem_text = thm.text
 
+        self._content_till_last_theorem_stmt = "\n".join(self._lines_executed)
+        assert not theorem_text.endswith(':='), "Theorem text should not end with ':='"
+        if SimpleLean4SyncExecutor.ends_with_by_sorry_match.search(theorem_text):
+            # Remove the ':= by sorry' part
+            theorem_text = SimpleLean4SyncExecutor.ends_with_by_sorry_match.sub('', theorem_text).strip() + " :="
+        else:
+            theorem_text = theorem_text + " :="
         content_until_after_theorem = "\n".join(self._lines_executed) + "\n" + theorem_text
-
-        # Parse out tactics now
-        all_tactics_till_now, _ = self.tactic_parser.parse(content_until_after_theorem, fail_on_error=True, parse_type=RequestType.PARSE_TACTICS)
-        # Find the first index which is after the theorem line
-        first_idx_after_theorem = None
-        for idx, tactic_info in enumerate(all_tactics_till_now):
-            if tactic_info.line >= line_num:
-                first_idx_after_theorem = idx
-                break
-        if first_idx_after_theorem is None:
+        self._content_till_after_theorem_stmt = content_until_after_theorem.strip()
+        assert self._content_till_after_theorem_stmt.endswith(':='), "Content till last theorem statement should not end with ':='"
+        # Check if we should follow steps as it is or not
+        follow_steps = self.main_file is not None and self.associated_file() == self.main_file
+        if follow_steps and \
+        thm.proof is not None and \
+        not SimpleLean4SyncExecutor.theorem_has_by_match.match(thm.proof):
             msg = "Could not find the first tactic after the theorem" + \
             f" only tactic based proofs are supported. Theorem: '{theorem}' on line {line_num}, file: '{self.main_file}'" + \
             " is probably not followed by any tactic based proof." + \
             " All tactics parsed till now:\n" + \
-            "\n".join([f"L {t.line}, C {t.column}: {t.text}" for t in all_tactics_till_now]) + \
+            f"{thm.proof}" + \
             "\n^^^ Cannot see tactics for the theorem."
             raise NotImplementedError(msg)
-        start_tactic = all_tactics_till_now[first_idx_after_theorem]
-        tactic_start_line = start_tactic.line
-        tactic_start_col = start_tactic.column
+        # It is safe to assume that this is a tactic based proof so we can extract steps or change the proof steps going forward
+        lines_in_theorem_text = theorem_text.splitlines()
+        tactic_start_line = line_num + len(lines_in_theorem_text) - 1
         assert tactic_start_line > 0, "Tactic start line should be greater than 0"
-        content_until_after_theorem = "\n".join(lines[:tactic_start_line - 1] + [lines[tactic_start_line - 1][:tactic_start_col]])
-        self._content_till_after_theorem_stmt = content_until_after_theorem
-        self._content_till_after_theorem_stmt = self._content_till_after_theorem_stmt.strip()
-        assert self._content_till_after_theorem_stmt.endswith(':='), "Content till last theorem statement should end with ':='"
-        content_until_before_theorem = "\n".join(lines[:line_num - 1])
-        self._content_till_last_theorem_stmt = content_until_before_theorem
-        theorem_stmt = "\n".join(lines[line_num - 1:tactic_start_line - 1] + [lines[tactic_start_line - 1][:tactic_start_col]])
-        theorem_stmt = theorem_stmt.strip()
-        self._last_theorem = (given_theorem_name, theorem_stmt, theorem_stmt)
+        self._last_theorem = (given_theorem_name, theorem_text, theorem_text)
         self._theorem_started = True
-        self._lines_executed.extend(lines[line_num - 1:tactic_start_line - 1] + [lines[tactic_start_line - 1][:tactic_start_col]])
-        self._run_stmt_on_lean_server(tactic_start_line, "by", theorem_started=True)
-        self._lines_executed.append('by')
+        self._lines_executed.extend(lines_in_theorem_text)
+        starting_tactics = '\n'.join(self._starting_tactic_sequence)
+        self._run_stmt_on_lean_server(tactic_start_line, starting_tactics, theorem_started=True)
+        self._lines_executed.append(starting_tactics)
         # Reset the iterator to the line of the theorem
         if lines[tactic_start_line - 1].strip().endswith("by"):
             self.main_file_iter.set_to_index(tactic_start_line)
@@ -674,6 +736,36 @@ class SimpleLean4SyncExecutor:
         else:
             return ProofContext(goals, [], [], [])
 
+    def _get_temp_cache_dir(self) -> str:
+        temp_cache = gettempdir()
+        list_dir = []
+        for d in os.listdir(temp_cache):
+            if d.startswith("itp_interface_lean4_cache_"):
+                list_dir.append(d)
+        # Create a new cache directory
+        unique_dir_name = f"itp_interface_lean4_cache_{max(0, len(list_dir) - 1)}"
+        temp_cache_dir = os.path.join(temp_cache, unique_dir_name)
+        os.makedirs(temp_cache_dir, exist_ok=True)
+        return temp_cache_dir
+    
+    def _get_file_path_in_cache(self) -> str | None:
+        temp_cache_dir = self._get_temp_cache_dir()
+        file_path = self.associated_file()
+        if file_path is None:
+            return None
+        else:
+            # look for the last time file was modified
+            file_mtime = os.path.getmtime(file_path)
+            file_mtime_str = "".join(str(file_mtime).split('.'))
+            # Convert file path to base64 and use that as the file name
+            fp_encoded = base64.urlsafe_b64encode(file_path.encode()).decode()
+            fp_encoded = f"b64_{fp_encoded}"
+            file_name_with_timestamp = f"{fp_encoded}_{file_mtime_str}.json"
+            return os.path.join(temp_cache_dir, file_name_with_timestamp)
+    
+    def _get_lock_file_path_in_cache(self, file_path: str) -> str:
+        return file_path + ".lock"
+
     def validate_proof(self, timeout_sec: int = 30, keep_temp_file: bool = True) -> typing.Dict[str, typing.Any]:
         """
         Validate the current proof state by running 'lake lean' on a temporary file.
@@ -708,7 +800,6 @@ class SimpleLean4SyncExecutor:
 
         # Build the complete Lean code with actual proof tactics
         # The proof tactics are accumulated in self.possible_proof_tactics
-        actual_proof = ""  # Track the actual proof for sorry checking
         proof_tactics_source = self.possible_proof_tactics
 
         # If possible_proof_tactics is empty, try to use _last_tactics as fallback
@@ -875,7 +966,7 @@ def get_all_theorems_in_file(file_path: str, use_cache: bool=False) -> List[Theo
     open_namespaces = []
     with open(file_path, "r") as f:
         file_content = f.read()
-    line_by_line_reader = LeanLineByLineReader(file_content=file_content, remove_comments=True, no_strip=True)
+    line_by_line_reader = LeanLineByLineReader(file_content=file_content, remove_comments=False, no_strip=True)
     all_stmts = list(line_by_line_reader.instruction_step_generator())
     line_positions = [0] + [len(stmt) + 1 for stmt in all_stmts]
     # Cumulative sum of the line positions
@@ -959,11 +1050,21 @@ def get_theorem_name_resembling(file_path: str, theorem_name: str, use_cache: bo
                 return json.dumps(dict_thm)
         raise ValueError(f"The theorem '{theorem_name}' was not found in the file '{file_path}'")
 
-def execute_thm_line_by_line(file_path: str, project_root: str, theorem_name: str, logger: logging.Logger, with_print: bool=False):
+def execute_thm_line_by_line(file_path: str, project_root: str, theorem_name: str, logger: logging.Logger, with_print: bool=False, starting_tactic_sequence: List[str]=[]) -> None:
     pprint = lambda msg: print(msg) if with_print else None
-    with SimpleLean4SyncExecutor(main_file=file_path, project_root=project_root, logger=logger) as executor:
+    with SimpleLean4SyncExecutor(main_file=file_path, project_root=project_root, logger=logger, starting_tactic_sequence=starting_tactic_sequence) as executor:
         executor.set_run_exactly()
         executor._skip_to_theorem(theorem_name)
+        if len(starting_tactic_sequence) > 0:
+            # It can happen that the starting tactic sequence already finishes the proof
+            proof_context_empty = executor.proof_context is None or executor.proof_context == ProofContext.empty()
+            no_error_messages = len(executor.lean_error_messages) == 0
+            if proof_context_empty and no_error_messages:
+                pprint("Proof finished with starting tactic sequence")
+                return
+            if len(executor.lean_error_messages) > 0:
+                pprint(f"Error messages after starting tactic sequence:\n{executor.lean_error_messages}")
+                return
         assert executor.proof_context is not None, "Proof context should be present"
         proof_exec = False
         while not executor.execution_complete:

{itp_interface-1.3.0 → itp_interface-1.5.0}/src/itp_interface/lean/tactic_parser.py

@@ -289,35 +289,42 @@ def get_path_to_tactic_parser_executable() -> str:
     tactic_parser_bin_path = os.path.join(abs_path, ".lake", "build", "bin", "tactic-parser")
     return tactic_parser_bin_path
 
+def toolchain_version_and_env_version():
+    lean_version_needed = os.getenv("LEAN_VERSION", None)
+    tactic_parser_project = get_path_to_tactic_parser_project()
+    # Check the version of the built parser
+    toolchain_file = os.path.join(tactic_parser_project, "lean-toolchain")
+    assert os.path.isfile(toolchain_file), f"lean-toolchain file not found at {toolchain_file}, something is wrong."
+    with open(toolchain_file, 'r') as f:
+        toolchain_content = f.read()
+    toolchain_content = toolchain_content.strip()
+    return toolchain_file, toolchain_content, lean_version_needed
+
+def change_toolchain_version(lean_version_needed: str, toolchain_file: str, toolchain_content: str):
+    # Replace the version in the toolchain file
+    # The version should be like 4.x.y
+    pattern = r'^4\.\d+\.\d+$'
+    if not re.match(pattern, lean_version_needed):
+        raise RuntimeError(f"Tactic parser built with Lean version {toolchain_content}, but version {lean_version_needed} is required." +
+        "Don't know how to build Lean which is not of the form 4.x.y. " +
+        "Please rebuild the tactic parser.")
+    toolchain_final = f"leanprover/lean4:v{lean_version_needed}"
+    with open(toolchain_file, 'w') as f:
+        f.write(toolchain_final)
+
 def is_tactic_parser_built() -> bool:
     """Check if the tactic parser executable exists."""
     path_to_exec = get_path_to_tactic_parser_executable()
+    toolchain_file, toolchain_content, lean_version_needed = toolchain_version_and_env_version()
     if not os.path.isfile(path_to_exec):
+        if lean_version_needed is not None:
+            change_toolchain_version(lean_version_needed, toolchain_file, toolchain_content)
         return False
     else:
-        lean_version_needed = os.getenv("LEAN_VERSION", None)
-        if lean_version_needed is None:
-            return True
-        tactic_parser_project = get_path_to_tactic_parser_project()
-        # Check the version of the built parser
-        toolchain_file = os.path.join(tactic_parser_project, "lean-toolchain")
-        assert os.path.isfile(toolchain_file), f"lean-toolchain file not found at {toolchain_file}, something is wrong."
-        with open(toolchain_file, 'r') as f:
-            toolchain_content = f.read()
-        toolchain_content = toolchain_content.strip()
-        if toolchain_content.endswith(lean_version_needed):
+        if lean_version_needed is None or toolchain_content.endswith(lean_version_needed):
             return True
         else:
-            # Replace the version in the toolchain file
-            # The version should be like 4.x.y
-            pattern = r'^4\.\d+\.\d+$'
-            if not re.match(pattern, lean_version_needed):
-                raise RuntimeError(f"Tactic parser built with Lean version {toolchain_content}, but version {lean_version_needed} is required." +
-                "Don't know how to build Lean which is not of the form 4.x.y. " +
-                "Please rebuild the tactic parser.")
-            toolchain_final = f"leanprover/lean4:v{lean_version_needed}"
-            with open(toolchain_file, 'w') as f:
-                f.write(toolchain_final)
+            change_toolchain_version(lean_version_needed, toolchain_file, toolchain_content)
             return False
 
 def build_lean4_project(project_folder, logger: Optional[logging.Logger] = None, has_executable: bool = False):

{itp_interface-1.3.0 → itp_interface-1.5.0}/src/itp_interface/rl/proof_action.py

@@ -30,12 +30,15 @@ class ProofAction(Action):
         GET_DFNS_THMS = 'GET_DFNS_THMS'
         RUN_TACTIC = 'RUN_TACTIC'
         BACKTRACK = 'BACKTRACK'
+        FULL_BACKTRACK = 'FULL_BACKTRACK'
         EXIT = 'EXIT'
         NONE = 'NONE'
 
         @staticmethod
         def get_order(action_type: 'ProofAction.ActionType'):
             if action_type == ProofAction.ActionType.EXIT:
+                return 8
+            elif action_type == ProofAction.ActionType.FULL_BACKTRACK:
                 return 7
             elif action_type == ProofAction.ActionType.BACKTRACK:
                 return 6