itp-interface 1.4.0__tar.gz → 1.6.0__tar.gz

{itp_interface-1.4.0 → itp_interface-1.6.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 create -n py314-ft python=3.14 python-freethreading pip -c conda-forge -y
+          conda clean -all -y
 
       - name: Check Python version and GIL status
         shell: bash
@@ -51,8 +55,10 @@ jobs:
         run: |
           export PATH="$HOME/miniconda/bin:$PATH"
           source $HOME/miniconda/bin/activate py314-ft
+          mkdir -p /root/.docker && chmod 700 /root/.docker
           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 +73,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 +93,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.4.0 → itp_interface-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itp_interface
-Version: 1.4.0
+Version: 1.6.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
@@ -51,6 +51,8 @@ Generic interface for hooking up to any Interactive Theorem Prover (ITP) and col
 
 ## 🎉 What's New
 
+**Lean v4.25–v4.30 Support** (May 2026) - `itp-interface` now supports Lean 4 versions v4.25.0 through v4.30.0, extending the previously supported range of v4.15–v4.24.
+
 **Python 3.14 Free-Threading Support** (January 2025) - `itp-interface` now supports Python 3.14's experimental free-threading mode (GIL-free execution)! Experience true parallel proof search with up to 2.13x speedup on multi-core systems. The interface automatically detects your Python version and seamlessly falls back to thread-based parallelism when Ray is unavailable. See [Python 3.14 Free-Threading Support](#python-314-free-threading-support-optional) for details. 
 
 ## Quick Setup for Lean 4:
@@ -60,7 +62,7 @@ pip install itp-interface
 ```
 
 2. Run the following command to prepare the REPL for Lean 4. The default version is 4.24.0. You can change the version by setting the `LEAN_VERSION` environment variable. If no version is set, then 4.24.0 is used.
->NOTE: The Lean 4 version must match the version of the Lean 4 project you are working with. `itp-interface` **supports Lean 4 version >= 4.15.0 and <= 4.24.0**. (It has been tested till version 4.24.0, but might as well work for future versions too, if the future versions are completely backwards-compatible).
+>NOTE: The Lean 4 version must match the version of the Lean 4 project you are working with. `itp-interface` **supports Lean 4 versions v4.15.0 through v4.30.0**. (It has been tested till version 4.30.0, but might as well work for future versions too, if the future versions are completely backwards-compatible).
 
 ```bash
 install-lean-repl
@@ -72,6 +74,10 @@ install-lean-repl
 ```bash
 install-itp-interface
 ```
+>NOTE: `install-itp-interface` also respects the `LEAN_VERSION` environment variable to determine which Lean version to compile the tactic parser with. It defaults to `4.24.0` when not set. **Both `install-lean-repl` and `install-itp-interface` must use the same `LEAN_VERSION`** — mismatching versions will cause elaboration errors at runtime. If you set `LEAN_VERSION` for one, set it for both:
+```bash
+export LEAN_VERSION="4.30.0" && install-lean-repl && install-itp-interface
+```
 
 >NOTE: These steps are only tested on Linux. For Windows, you can use WSL. These steps will not setup the Coq interface.
 

{itp_interface-1.4.0 → itp_interface-1.6.0}/README.md

@@ -7,6 +7,8 @@ Generic interface for hooking up to any Interactive Theorem Prover (ITP) and col
 
 ## 🎉 What's New
 
+**Lean v4.25–v4.30 Support** (May 2026) - `itp-interface` now supports Lean 4 versions v4.25.0 through v4.30.0, extending the previously supported range of v4.15–v4.24.
+
 **Python 3.14 Free-Threading Support** (January 2025) - `itp-interface` now supports Python 3.14's experimental free-threading mode (GIL-free execution)! Experience true parallel proof search with up to 2.13x speedup on multi-core systems. The interface automatically detects your Python version and seamlessly falls back to thread-based parallelism when Ray is unavailable. See [Python 3.14 Free-Threading Support](#python-314-free-threading-support-optional) for details. 
 
 ## Quick Setup for Lean 4:
@@ -16,7 +18,7 @@ pip install itp-interface
 ```
 
 2. Run the following command to prepare the REPL for Lean 4. The default version is 4.24.0. You can change the version by setting the `LEAN_VERSION` environment variable. If no version is set, then 4.24.0 is used.
->NOTE: The Lean 4 version must match the version of the Lean 4 project you are working with. `itp-interface` **supports Lean 4 version >= 4.15.0 and <= 4.24.0**. (It has been tested till version 4.24.0, but might as well work for future versions too, if the future versions are completely backwards-compatible).
+>NOTE: The Lean 4 version must match the version of the Lean 4 project you are working with. `itp-interface` **supports Lean 4 versions v4.15.0 through v4.30.0**. (It has been tested till version 4.30.0, but might as well work for future versions too, if the future versions are completely backwards-compatible).
 
 ```bash
 install-lean-repl
@@ -28,6 +30,10 @@ install-lean-repl
 ```bash
 install-itp-interface
 ```
+>NOTE: `install-itp-interface` also respects the `LEAN_VERSION` environment variable to determine which Lean version to compile the tactic parser with. It defaults to `4.24.0` when not set. **Both `install-lean-repl` and `install-itp-interface` must use the same `LEAN_VERSION`** — mismatching versions will cause elaboration errors at runtime. If you set `LEAN_VERSION` for one, set it for both:
+```bash
+export LEAN_VERSION="4.30.0" && install-lean-repl && install-itp-interface
+```
 
 >NOTE: These steps are only tested on Linux. For Windows, you can use WSL. These steps will not setup the Coq interface.
 

{itp_interface-1.4.0 → itp_interface-1.6.0}/pyproject.toml

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

{itp_interface-1.4.0 → itp_interface-1.6.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.4.0 → itp_interface-1.6.0}/src/itp_interface/lean/simple_lean4_sync_executor.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 
+from contextlib import nullcontext
 import os
 import base64
 import copy
@@ -11,6 +12,7 @@ import json
 import typing
 import bisect
 import subprocess
+from filelock import FileLock
 from itp_interface.lean.tactic_parser import (
     TacticParser, 
     ErrorInfo, 
@@ -36,6 +38,8 @@ class SimpleLean4SyncExecutor:
     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"
@@ -56,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, \
@@ -121,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
@@ -291,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]
@@ -600,48 +612,53 @@ class SimpleLean4SyncExecutor:
         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"
         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
-        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)]
+        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)
-                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)
+                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)
@@ -670,7 +687,11 @@ class SimpleLean4SyncExecutor:
 
         self._content_till_last_theorem_stmt = "\n".join(self._lines_executed)
         assert not theorem_text.endswith(':='), "Theorem text should not end with ':='"
-        theorem_text = theorem_text + " :="
+        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
         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 ':='"
@@ -693,8 +714,9 @@ class SimpleLean4SyncExecutor:
         self._last_theorem = (given_theorem_name, theorem_text, theorem_text)
         self._theorem_started = True
         self._lines_executed.extend(lines_in_theorem_text)
-        self._run_stmt_on_lean_server(tactic_start_line, "by", theorem_started=True)
-        self._lines_executed.append('by')
+        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)
@@ -740,6 +762,9 @@ class SimpleLean4SyncExecutor:
             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]:
         """
@@ -775,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
@@ -1026,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.6.0/src/itp_interface/lean/tactic_parser/TacticParser/Compat.lean

@@ -0,0 +1,81 @@
+import Lean
+
+/-!
+# Compatibility shims for Lean version skew
+
+In Lean v4.27, `String.Pos` was split into two types:
+
+  * `String.Pos s` (new, dependent): `{ offset : Pos.Raw, isValid : offset.IsValid s }`
+  * `String.Pos.Raw` (new, flat):    `{ byteIdx : Nat }` — the old `String.Pos`
+
+Several `String` operations also changed return type:
+
+  * `String.drop`, `String.take`, `String.extract`, `String.takeWhile`, etc.
+    now return `String.Slice` (which has a `.copy : String.Slice → String`).
+    Pre-v4.27 they returned `String` directly.
+
+The `TacticParser` source uses the v4.27 spellings (`String.Pos.Raw.extract`,
+`.offset.byteIdx`, `.copy`, `rawEndPos`). To stay buildable on the README's
+documented range (4.15.0 – 4.24.0) as well as v4.27.0, this file provides
+shims that are elaborated *only* on pre-v4.27 toolchains; on v4.27+ they are
+skipped, so the real core definitions are used.
+
+The `compat_pre_v427` macro is a tiny preprocessor that runs its body iff
+`Lean.versionString` parses to `< 4.27`.
+-/
+
+open Lean Elab Command
+
+/-- True iff the current Lean toolchain is older than v4.27. -/
+private def itpInterface_isPreV427 : Bool := Id.run do
+  let parts := Lean.versionString.splitOn "."
+  let some majorStr := parts.head?         | return false
+  let some minorStr := parts[1]?           | return false
+  let some major    := majorStr.toNat?     | return false
+  -- Strip any suffix like "-rc1" before parsing minor.
+  let minorClean := minorStr.takeWhile Char.isDigit
+  let some minor    := minorClean.toNat?   | return false
+  return major < 4 || (major == 4 && minor < 27)
+
+/-- Elaborate the body iff the current Lean toolchain is older than v4.27. -/
+syntax (name := compatPreV427) "compat_pre_v427 " command* : command
+
+@[command_elab compatPreV427]
+def elabCompatPreV427 : CommandElab := fun stx => do
+  if itpInterface_isPreV427 then
+    let cmds := stx[1].getArgs
+    for c in cmds do
+      elabCommand c
+
+-- ---------------------------------------------------------------------------
+-- Pre-v4.27 shims.
+--
+-- On v4.27 these are NOT elaborated; the real core definitions are used.
+-- On v4.15–4.24 these introduce the v4.27 spellings as thin wrappers.
+-- ---------------------------------------------------------------------------
+
+compat_pre_v427
+  /-- Pre-v4.27 alias: the (then-flat) `String.Pos` plays the role of the new
+      `String.Pos.Raw`. -/
+  abbrev String.Pos.Raw : Type := String.Pos
+
+  namespace String.Pos.Raw
+    /-- Pre-v4.27 shim mirroring the v4.27 positional spelling
+        `String.Pos.Raw.extract s b e`. -/
+    def extract (s : String) (b e : String.Pos) : String := s.extract b e
+  end String.Pos.Raw
+
+  /-- Pre-v4.27 shim: in v4.27 a `String` exposes a flat past-the-end accessor
+      `rawEndPos : Pos.Raw`. Pre-v4.27 only has `endPos`. -/
+  def String.rawEndPos (s : String) : String.Pos := s.endPos
+
+  namespace String.Pos
+    /-- Pre-v4.27 shim: in v4.27 a dependent `String.Pos s` carries a `.offset : Pos.Raw`
+        field. Pre-v4.27 the position is already flat, so `.offset` is the identity. -/
+    def offset (p : String.Pos) : String.Pos := p
+  end String.Pos
+
+  /-- Pre-v4.27 shim: in v4.27 `String.drop`/`take`/`extract`/`takeWhile` return
+      `String.Slice` and call sites use `.copy` to materialise back to `String`.
+      Pre-v4.27 they already return `String`, so `.copy` is the identity. -/
+  def String.copy (s : String) : String := s

{itp_interface-1.4.0 → itp_interface-1.6.0}/src/itp_interface/lean/tactic_parser/TacticParser/DependencyParser.lean

@@ -35,9 +35,9 @@ def filePathToModuleName (filepath : System.FilePath) : String :=
   let modulePath := withoutExt.replace "/" "."
   -- Remove leading ./ if present
   if modulePath.startsWith ".." then
-    modulePath.drop 2
+    (modulePath.drop 2).copy
   else if modulePath.startsWith "." then
-    modulePath.drop 1
+    (modulePath.drop 1).copy
   else
     modulePath
 
@@ -162,7 +162,7 @@ partial def findImports (stx : Syntax) (content: String) : IO (Array ImportInfo)
         match stx.getRange? with
         | some range =>
           let moduleName := extractModuleName stx
-          let text := content.extract range.start range.stop
+          let text := String.Pos.Raw.extract content range.start range.stop
           let info : ImportInfo := {
             moduleName := moduleName
             startPos := range.start.byteIdx
@@ -215,7 +215,7 @@ def parseImports (filepath : System.FilePath) : IO DependencyInfo := do
       match stx.getRange? with
       | some range =>
         let namespaceName := extractModuleName stx
-        let text := content.extract range.start range.stop
+        let text := String.Pos.Raw.extract content range.start range.stop
         let info : NamespaceInfo := {
           name := namespaceName
           startPos := range.start.byteIdx

{itp_interface-1.4.0 → itp_interface-1.6.0}/src/itp_interface/lean/tactic_parser/TacticParser/LineParser.lean

@@ -103,20 +103,20 @@ partial def trimComment (text : String) (state : Nat := 0) (depth : Nat := 0) :
     let newState := 0
     -- Go till the end of line
     let endOfLine := text.find (fun c => c == '\n')
-    let remaining := text.drop endOfLine.byteIdx
+    let remaining := (text.drop endOfLine.offset.byteIdx).copy
     let ep := trimComment remaining newState depth
-    endOfLine.byteIdx + ep
+    endOfLine.offset.byteIdx + ep
   else if text.startsWith "/-" ∧ state == 0 then
     -- starting of a block comment
     let newState := 1
-    let remaining := text.drop 2
+    let remaining := (text.drop 2).copy
     let ep := trimComment remaining newState (depth + 1)
     ep + 2
   else if text.startsWith "-/" ∧ state == 1 then
     -- ending of a block comment
     let newDepth := depth - 1
     let newState := if newDepth == 0 then 0 else 1
-    let remaining := text.drop 2
+    let remaining := (text.drop 2).copy
     let ep := trimComment remaining newState newDepth
     ep + 2
   else if text.length == 0 then
@@ -127,7 +127,7 @@ partial def trimComment (text : String) (state : Nat := 0) (depth : Nat := 0) :
       -- not in comment and no leading spaces, stop
       0
     else
-      let remaining := text.drop 1
+      let remaining := (text.drop 1).copy
       let ep := trimComment remaining state depth
       ep + 1
 
@@ -150,8 +150,8 @@ def postProcess (text : String) : String × List Nat :=
   let lines := text.splitOn "\n"
   let processedLines := lines.mapIdx fun i line =>
     if line.trimLeft.startsWith "lemma " then
-      let leadingSpaces := line.takeWhile (fun c => c == ' ' ∨ c == '\t')
-      let newLine := leadingSpaces ++ "theorem " ++ line.trimLeft.drop "lemma ".length
+      let leadingSpaces := (line.takeWhile (fun c => c == ' ' ∨ c == '\t')).copy
+      let newLine := leadingSpaces ++ "theorem " ++ (line.trimLeft.drop "lemma ".length).copy
       (newLine, lines.length)
       --(newLine, lines.length)
     else
@@ -169,7 +169,7 @@ unsafe def parseCommon
   : IO (Array DeclInfo) := do
   -- First pass: parse all commands and collect their positions
   -- We parse the ORIGINAL content to find declaration boundaries
-  let mut commands : Array (String.Pos × Syntax) := #[]
+  let mut commands : Array (String.Pos.Raw × Syntax) := #[]
   let mut pstate := parserState
   let mut done := false
 
@@ -207,20 +207,20 @@ unsafe def parseCommon
       let nextRealStart := match nextStx.getRange? with
         | some range => range.start
         | none => nextParsePos
-      ⟨nextRealStart.byteIdx - 1⟩
+      (⟨nextRealStart.byteIdx - 1⟩ : String.Pos.Raw)
     else
-      ⟨originalContent.endPos.byteIdx⟩
+      (⟨originalContent.rawEndPos.byteIdx⟩ : String.Pos.Raw)
 
     -- Extract text from ORIGINAL content
-    let text := originalContent.extract realStart endPos
+    let text := String.Pos.Raw.extract originalContent realStart endPos
 
     -- Strip comments to check if this starts with "lemma"
     let commentEnd := trimComment text
-    let docStringStr := (text.take commentEnd).trim
+    let docStringStr := (text.take commentEnd).copy.trim
     let mut docString := none
     if !docStringStr.isEmpty then
       docString := some docStringStr
-    let textWithoutComments := text.drop commentEnd
+    let textWithoutComments := (text.drop commentEnd).copy
     let isLemma := textWithoutComments.startsWith "lemma "
 
     -- Print the docstring and the text without comments for debugging
@@ -233,9 +233,9 @@ unsafe def parseCommon
     if isLemma then
     -- If it's a lemma, preprocess it for parsing
       -- replace the "lemma" at the end position of the comment with "theorem"
-      textToParse := text.take commentEnd ++
+      textToParse := (text.take commentEnd).copy ++
                      "theorem " ++
-                     textWithoutComments.drop "lemma ".length
+                     (textWithoutComments.drop "lemma ".length).copy
 
     let declInputCtx := mkInputContext textToParse "<input>"
     let (_, declParserState, _) ← parseHeader declInputCtx
@@ -245,14 +245,14 @@ unsafe def parseCommon
     let declType := identifyDeclType declStx
     let name := extractDeclName declStx
 
-    if declType == .namespace then
+    if declType == DeclType.namespace then
       openNamespaces := openNamespaces.append [name]
-    else if declType == .end then
+    else if declType == DeclType.end then
       -- Pop the last opened namespace if any
       openNamespaces := openNamespaces.dropLast
 
     -- If we preprocessed it and it parsed as theorem, it's actually a lemma
-    let actualDeclType := if isLemma && declType == .theorem then .lemma else declType
+    let actualDeclType := if isLemma && declType == DeclType.theorem then DeclType.lemma else declType
     let namespc :=
       if openNamespaces.isEmpty then
         none
@@ -334,7 +334,7 @@ def printDeclInfo (info : DeclInfo) : IO Unit := do
   IO.println s!"[{info.declType}] {info.name}"
   IO.println s!"  Position: {toJson info.startPos} - {toJson info.endPos}"
   let preview := if info.text.length > 100 then
-    info.text.take 50 ++ "\n ... more text ... \n" ++ info.text.drop (info.text.length - 50)
+    (info.text.take 50).copy ++ "\n ... more text ... \n" ++ (info.text.drop (info.text.length - 50)).copy
   else
     info.text
   IO.println s!"  Text: {preview}"
@@ -476,11 +476,9 @@ end Lean4Proj2
 
 #eval parseDecls test_str
 
-#eval (test_str.extract ⟨15⟩ ⟨37⟩)
-
-#eval (test_str.extract ⟨37⟩ ⟨58⟩)
-
-#eval (test_str.extract ⟨298⟩ ⟨912⟩)
+-- v4.27 port: removed test cases using ⟨n⟩ numeric String.Pos literals
+-- (the dependent String.Pos in v4.27 no longer accepts a single-field anonymous
+-- constructor with bare numerals). Replace with `String.Pos.Raw.extract test_str (⟨15⟩ : String.Pos.Raw) (⟨37⟩ : String.Pos.Raw)` if needed.
 
 #eval get_position_from_char_pos test_str 57 -- expect line 4, column 20