lean-interact 0.9.2__tar.gz → 0.10.0__tar.gz

{lean_interact-0.9.2 → lean_interact-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-interact
-Version: 0.9.2
+Version: 0.10.0
 Summary: LeanInteract is a Python package that allows you to interact with the Lean theorem prover.
 Author-email: Auguste Poiroux <auguste.poiroux@epfl.ch>
 License: MIT License
@@ -53,7 +53,7 @@ Check the [documentation](https://augustepoiroux.github.io/LeanInteract/) for de
 - **🔗 Interactivity**: Execute Lean code and files directly from Python.
 - **🚀 Ease of Use**: LeanInteract abstracts the complexities of Lean setup and interaction.
 - **💻 Cross-platform**: Works on Windows, macOS, and Linux operating systems.
-- **🔧 Compatibility**: Supports all Lean versions between `v4.8.0-rc1` and `v4.25.0-rc2`.
+- **🔧 Compatibility**: Supports all Lean versions between `v4.8.0-rc1` and `v4.25.1`.
   - We backport the latest features of Lean REPL to older versions of Lean (see [fork](https://github.com/augustepoiroux/repl)).
 - **📦 Temporary Projects**: Easily instantiate temporary Lean environments.
   - Useful for experimenting with benchmarks depending on [Mathlib](https://github.com/leanprover-community/mathlib4) like [ProofNet#](https://huggingface.co/datasets/PAug/ProofNetSharp) and [MiniF2F](https://github.com/yangky11/miniF2F-lean4).

{lean_interact-0.9.2 → lean_interact-0.10.0}/README.md

@@ -15,7 +15,7 @@ Check the [documentation](https://augustepoiroux.github.io/LeanInteract/) for de
 - **🔗 Interactivity**: Execute Lean code and files directly from Python.
 - **🚀 Ease of Use**: LeanInteract abstracts the complexities of Lean setup and interaction.
 - **💻 Cross-platform**: Works on Windows, macOS, and Linux operating systems.
-- **🔧 Compatibility**: Supports all Lean versions between `v4.8.0-rc1` and `v4.25.0-rc2`.
+- **🔧 Compatibility**: Supports all Lean versions between `v4.8.0-rc1` and `v4.25.1`.
   - We backport the latest features of Lean REPL to older versions of Lean (see [fork](https://github.com/augustepoiroux/repl)).
 - **📦 Temporary Projects**: Easily instantiate temporary Lean environments.
   - Useful for experimenting with benchmarks depending on [Mathlib](https://github.com/leanprover-community/mathlib4) like [ProofNet#](https://huggingface.co/datasets/PAug/ProofNetSharp) and [MiniF2F](https://github.com/yangky11/miniF2F-lean4).

{lean_interact-0.9.2 → lean_interact-0.10.0}/docs/api/sessioncache.md

@@ -1,9 +1,13 @@
+# Session Cache API
+
 ::: lean_interact.sessioncache
     options:
       heading_level: 1
       heading: "Session Cache"
       show_symbol_type_heading: false
       members:
+        - ReplaySessionCache
         - PickleSessionCache
         - SessionState
+        - ReplaySessionState
         - PickleSessionState

{lean_interact-0.9.2 → lean_interact-0.10.0}/docs/index.md

@@ -17,7 +17,7 @@ hide:
 - **🔗 Interactivity**: Execute Lean code and files directly from Python
 - **🚀 Ease of Use**: LeanInteract abstracts the complexities of Lean setup and interaction
 - **💻 Cross-platform**: Works on Windows, macOS, and Linux operating systems
-- **🔧 Compatibility**: Supports all Lean versions between `v4.8.0-rc1` and `v4.25.0-rc2`
+- **🔧 Compatibility**: Supports all Lean versions between `v4.8.0-rc1` and `v4.25.1`
     - We backport the latest features of Lean REPL to older versions of Lean (see [fork](https://github.com/augustepoiroux/repl)).
 - **📦 Temporary Projects**: Easily instantiate temporary Lean environments
     - Useful for experimenting with benchmarks depending on [Mathlib](https://github.com/leanprover-community/mathlib4) like [ProofNet#](https://huggingface.co/datasets/PAug/ProofNetSharp) and [MiniF2F](https://github.com/yangky11/miniF2F-lean4)

{lean_interact-0.9.2 → lean_interact-0.10.0}/docs/user-guide/examples.md

@@ -73,8 +73,8 @@ print(result)  # Example raw output from the REPL
 
 For more comprehensive examples, check out the following scripts in the examples directory:
 
-1. [**multi_processing.py**](https://github.com/augustepoiroux/LeanInteract/blob/main/examples/multi_processing.py)  
-   Shows how to use multiprocessing with LeanInteract for parallel proof checking.
+1. [**parallelization.py**](https://github.com/augustepoiroux/LeanInteract/blob/main/examples/parallelization.py)  
+   Shows how to parallelize calls to LeanInteract for faster processing.
 
 2. [**proof_generation_and_autoformalization.py**](https://github.com/augustepoiroux/LeanInteract/blob/main/examples/proof_generation_and_autoformalization.py)  
    Shows how to use models like DeepSeek-Prover-V1.5 and Goedel-Prover on MiniF2F and ProofNet# benchmarks.

lean_interact-0.10.0/docs/user-guide/performance.md

@@ -0,0 +1,224 @@
+# Performance & Parallelization
+
+LeanInteract provides **three complementary performance layers** that can be combined:
+
+1. **Within-command speedups (inside a single Lean request)**
+     - **Incremental elaboration**: reuse previous elaboration results instead of starting from scratch.
+     - **Parallel elaboration**: use `Elab.async` so Lean elaborates independent parts in parallel.
+2. **Across-command speedups (multiple commands / tasks)**
+     - **External parallelization**: run several Lean servers in parallel, typically via `AutoLeanServer`.
+
+All three can be enabled together for maximum throughput: fast single commands (incremental + parallel elaboration) and high aggregate throughput across many commands (external parallelization).
+By default, **incremental elaboration** and **parallel elaboration** are enabled in `LeanREPLConfig`. **External parallelization** can be implemented in various ways, thus no default is provided.
+
+## Incremental Elaboration
+
+Incremental elaboration is a free performance boost that reduces latency and memory by automatically reusing elaboration results from prior commands executed on the same `LeanServer`.
+
+### How it works
+
+In Lean, incremental elaboration allows reusing the elaboration state of a prior command when elaborating a new command that shares a common prefix.
+For example, if you have already elaborated:
+
+```lean
+import Mathlib
+def foo : Nat := 42
+```
+
+and now want to elaborate:
+
+```lean
+import Mathlib
+def bar : Nat := 56
+```
+
+then Lean can reuse the elaboration state after `import Mathlib` from the first command instead of starting from scratch, effectively loading Mathlib only once.
+
+Incremental elaboration therefore **automatically finds the best incremental state from the previous command** to reuse for the new command. For VS Code users, this corresponds to how Lean4's built-in language server reuses elaboration states when editing files (vertical orange loading bar in the gutter).
+
+LeanInteract generalizes this mechanism further by extending the search for the best incremental state to reuse to **all prior commands** in the history, not just the most recent one. The optimal incremental state is found using a Trie-based data structure, which in practice has no noticeable overhead in both memory and CPU usage.
+
+### Properties
+
+- Write commands in any order without manually worrying about managing command states.
+- The Trie-based history lookup ensures that the best reuse point is found efficiently, independent of the number of prior commands.
+- In the worst case, memory and CPU usage will be similar to non-incremental elaboration (if no reuse is possible).
+- Particularly useful when checking batches of file edits or multiple similar commands.
+
+### How to use it
+
+- Create your `LeanREPLConfig` with default settings (or ensure `enable_incremental_optimization=True`).
+- Simply send commands to the same `LeanServer` instance as usual, incremental elaboration will be automatically applied.
+- **Recommendation:** Instead of splitting your code into small chunks like in a REPL, you should send full commands or file contents. LeanInteract will find the best reuse points automatically.
+
+### Example
+
+Below is a small script that measures the elapsed time of two "heavy" commands, but the second command benefits from incremental reuse:
+
+```python exec="on" source="above" session="perf" result="python"
+import time
+from lean_interact import LeanREPLConfig, LeanServer, Command
+
+server = LeanServer(LeanREPLConfig())
+
+t1 = time.perf_counter()
+print(server.run(Command(cmd="""
+def fib : Nat → Nat
+  | 0 => 0
+  | 1 => 1
+  | n + 2 => fib (n + 1) + fib n
+#eval fib 35
+
+theorem foo : n = n := by rfl
+#check foo
+""")))
+print(f"First run:  {time.perf_counter() - t1:.3f}s")
+
+t2 = time.perf_counter()
+print(server.run(Command(cmd="""
+def fib : Nat → Nat
+  | 0 => 0
+  | 1 => 1
+  | n + 2 => fib (n + 1) + fib n
+#eval fib 35
+
+theorem foo2 : n = n+0 := by rfl
+#check foo2
+""")))
+print(f"Second run: {time.perf_counter() - t2:.3f}s")
+```
+
+!!! warning Imports are cached
+    Imports are cached in incremental mode, meaning that if the content of one of your imported file has changed, it will not be taken into account unless you restart the server.
+
+You can disable this feature by setting `enable_incremental_optimization=False` in `LeanREPLConfig`.
+
+## Parallel Elaboration
+
+When supported (Lean >= v4.19.0), Lean can elaborate different parts of a command/file in parallel. LeanInteract auto-enables this by adding `set_option Elab.async true` to each request.
+You can disable it if needed by setting `enable_parallel_elaboration=False` in `LeanREPLConfig`.
+
+!!! note
+    Only available for Lean >= v4.19.0
+
+---
+
+## Parallelization Guide (multiple commands)
+
+LeanInteract is designed with parallelization in mind, allowing you to leverage multiple CPU cores for parallel theorem proving and verification tasks.
+
+This section focuses on **external parallelization**: running multiple Lean servers (usually via `AutoLeanServer`) in parallel threads, processes or workers. This is complementary to the within-command optimizations above and can be combined with them.
+
+We recommend using `AutoLeanServer`. It is specifically designed for parallel environments with automated restart on fatal Lean errors, timeouts, and when memory limits are reached. On automated restarts, only commands run with `add_to_session_cache=True` (attribute of the `AutoLeanServer.run` method) will be preserved.
+
+`AutoLeanServer` is still experimental, feedback and issues are welcome.
+
+### Best Practices Summary
+
+1. **Always pre-instantiate** `LeanREPLConfig` before parallelization
+2. **One lean server per process/thread**
+3. **Use `AutoLeanServer`**
+4. **Configure memory limits** to prevent system overload
+5. **Set appropriate timeouts** for long-running operations
+6. **Use session caching** to keep context between requests
+7. **Consider using `maxtasksperchild`** to limit memory accumulation
+
+### Quick Start
+
+```python
+from multiprocessing import Pool
+from lean_interact import AutoLeanServer, Command, LeanREPLConfig
+from lean_interact.interface import LeanError
+
+def worker(config: LeanREPLConfig, task_id: int):
+    """Worker function that runs in each process"""
+    server = AutoLeanServer(config)
+    result = server.run(Command(cmd=f"#eval {task_id} * {task_id}"))
+    return f"Task {task_id}: {result.messages[0].data if not isinstance(result, LeanError) else 'Error'}"
+
+# Pre-instantiate config before parallelization (downloads/initializes resources)
+config = LeanREPLConfig(verbose=True)
+with Pool() as p:
+    print(p.starmap(worker, [(config, i) for i in range(5)]))
+```
+
+For more examples, check the [examples directory](https://github.com/augustepoiroux/LeanInteract/tree/main/examples).
+
+### Core Principles
+
+#### 1. Pre-instantiate Configuration
+
+Always create your `LeanREPLConfig` instance **before** starting parallelization:
+
+```python
+from lean_interact import LeanREPLConfig, AutoLeanServer
+import multiprocessing as mp
+
+# ✅ CORRECT: Config created in main process
+config = LeanREPLConfig()  # Pre-setup in main process
+
+def worker(cfg):
+    server = AutoLeanServer(cfg)  # Use pre-configured config
+    # ... your work here
+    pass
+
+ctx = mp.get_context("spawn")
+with ctx.Pool() as pool:
+    pool.map(worker, [config] * 4)
+
+# ❌ INCORRECT: Config created in each process
+def worker():
+    config = LeanREPLConfig()
+    server = AutoLeanServer(config)
+    # ... your work here
+    pass
+
+ctx = mp.get_context("spawn")
+with ctx.Pool() as pool:
+    pool.map(worker, range(4))
+```
+
+#### 2. One Server Per Process/Thread
+
+Each process or thread should have its own `LeanServer` or `AutoLeanServer` instance.
+
+```python
+def worker(config, task_data):
+    # Each process gets its own server
+    server = AutoLeanServer(config)
+
+    for task in task_data:
+        result = server.run(task)
+        # Handle result
+
+    return results
+```
+
+### Thread Safety
+
+Within a single process, `LeanServer` and `AutoLeanServer` are thread-safe thanks to internal locking. All concurrent requests are processed sequentially. Across processes, servers are not shareable: each process must create its own instance.
+
+Similarly, `ReplaySessionCache` is thread-safe within a process, meaning multiple `AutoLeanServer` in different threads can safely share the same cache instance. However, across processes, each must have its own cache instance.
+
+### Memory Management
+
+```python
+from lean_interact import AutoLeanServer, LeanREPLConfig
+
+# Configure memory limits for multi-process safety
+config = LeanREPLConfig(memory_hard_limit_mb=8192)  # 8GB per server, works on Linux only
+
+server = AutoLeanServer(
+    config,
+    max_total_memory=0.8,      # Restart when system uses >80% memory
+    max_process_memory=0.8,    # Restart when process uses >80% of memory limit
+    max_restart_attempts=5     # Allow up to 5 restart attempts per command
+)
+```
+
+#### Memory Configuration Options
+
+- `max_total_memory`: System-wide memory threshold (0.0-1.0)
+- `max_process_memory`: Per-process memory threshold (0.0-1.0)
+- `memory_hard_limit_mb`: Hard memory limit in MB (Linux only)
+- `max_restart_attempts`: Maximum consecutive restart attempts

{lean_interact-0.9.2 → lean_interact-0.10.0}/examples/beq_plus.py

@@ -12,14 +12,20 @@
 
 Citation:
 ```bibtex
-@misc{poiroux2024improvingautoformalizationusingtype,
-    title={Improving Autoformalization using Type Checking},
-    author={Auguste Poiroux and Gail Weiss and Viktor Kunčak and Antoine Bosselut},
-    year={2024},
-    eprint={2406.07222},
-    archivePrefix={arXiv},
-    primaryClass={cs.CL},
-    url={https://arxiv.org/abs/2406.07222},
+@inproceedings{poiroux-etal-2025-reliable,
+    title = "Reliable Evaluation and Benchmarks for Statement Autoformalization",
+    author = "Poiroux, Auguste  and
+      Weiss, Gail  and
+      Kun{\v{c}}ak, Viktor  and
+      Bosselut, Antoine",
+    booktitle = "Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing",
+    month = nov,
+    year = "2025",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2025.emnlp-main.907/",
+    doi = "10.18653/v1/2025.emnlp-main.907",
+    pages = "17958--17980",
+    ISBN = "979-8-89176-332-6",
 }
 ```
 """
@@ -250,6 +256,12 @@ def beq_plus(
                 console.print(Syntax(proof_exact, "lean4"))
             continue
 
+        # If trivially provable by assumption, we skip
+        if check_proof_sub(server, formal_code, context_env, formal_2_start_line, "assumption", timeout_per_proof):
+            if verbose:
+                console.print("Skipping as provable by assumption")
+            continue
+
         # 2. try to apply the base theorem directly
         proof_apply = check_proof_sub(
             server,
@@ -340,6 +352,10 @@ open Set Real Ideal Polynomial
 open scoped BigOperators"""
 
     formalization_pairs = [
+        (  # negative example -- not semantically equivalent
+            "theorem prediction (a b : ℤ) (ha : a ∣ b) : a ∣ (b : ℤ) :=",
+            "theorem ground_truth (a b : ℤ) : (Zsqrtd.ofInt a : GaussianInt) ∣ Zsqrtd.ofInt b → a ∣ b :=",
+        ),
         (
             "theorem random_name_1 {G : Type*} [Group G] [Fintype G] (h : Fintype.card G % 2 = 0) :\n  ∃ a : G, a ≠ 1 ∧ a = a⁻¹ :=",
             "theorem random_name_2 {G : Type*} [Group G] [Fintype G] (hG2 : Even (card G)) :\n  ∃ (a : G), a ≠ 1 ∧ a = a⁻¹ :=",

lean_interact-0.10.0/examples/parallelization.py

@@ -0,0 +1,125 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["lean-interact", "joblib"]
+# ///
+"""
+Example demonstrating multi-processing and multi-threading with LeanInteract.
+
+This example shows the correct pattern for using LeanInteract with multiple processes:
+1. Pre-instantiate the config before starting multiprocessing
+2. Use spawn context for cross-platform compatibility
+3. Each process gets its own server instance
+
+Run this example with: python examples/parallelization.py
+"""
+
+import concurrent.futures
+import multiprocessing as mp
+import time
+from contextlib import contextmanager
+
+from joblib import Parallel, delayed  # type: ignore
+
+from lean_interact import AutoLeanServer, LeanREPLConfig
+from lean_interact.interface import Command, LeanError
+
+
+def worker(config: LeanREPLConfig, task_id: int) -> str:
+    """Worker function that runs in each process"""
+    try:
+        # Each process gets its own server instance
+        server = AutoLeanServer(config)
+        result = server.run(
+            Command(
+                cmd="""
+def fib : Nat → Nat
+  | 0 => 0
+  | 1 => 1
+  | n + 2 => fib (n + 1) + fib n
+#eval fib 32
+"""
+            )
+        )
+        if isinstance(result, LeanError):
+            return f"Task {task_id}: LeanError - {result}"
+        return f"Task {task_id}: {result.messages[0].data}"
+    except Exception as e:
+        return f"Task {task_id}: Exception - {e}"
+
+
+def setup() -> tuple[LeanREPLConfig, list[int]]:
+    print("Setting up LeanREPLConfig (may take a few minutes the first time)...")
+    config = LeanREPLConfig(verbose=True)
+    print("Config setup complete.")
+
+    # Dummy tasks
+    tasks = list(range(8))
+
+    return config, tasks
+
+
+@contextmanager
+def timed_section(title: str, *, summary_prefix: str | None = None):
+    print("\n\n" + "=" * 40)
+    print(title)
+    start_time = time.time()
+    try:
+        yield
+    finally:
+        elapsed = time.time() - start_time
+        label = summary_prefix or title
+        print(f"{label} took {elapsed:.2f} seconds.")
+
+
+def print_results(results: list[str]) -> None:
+    """Utility function to print results"""
+    print("\nResults:")
+    print("-" * 40)
+    for result in results:
+        print(result)
+
+
+def sequential_baseline(config: LeanREPLConfig, tasks: list[int]) -> None:
+    """Run tasks sequentially for baseline comparison"""
+    with timed_section("Sequential Baseline", summary_prefix="Sequential processing"):
+        results = []
+        for task_id in tasks:
+            result = worker(config, task_id)
+            results.append(result)
+    print_results(results)
+
+
+def multiprocessing_example(config: LeanREPLConfig, tasks: list[int]) -> None:
+    """Demonstrate multiprocessing with LeanInteract"""
+    with timed_section("Multi-processing Example", summary_prefix="Multi-processing"):
+        ctx = mp.get_context("spawn")
+        with ctx.Pool(processes=min(4, len(tasks))) as pool:
+            results = pool.starmap(worker, [(config, task_id) for task_id in tasks])
+    print_results(results)
+
+
+def multithreading_example(config: LeanREPLConfig, tasks: list[int]) -> None:
+    """Demonstrate multithreading with LeanInteract"""
+    with timed_section("Multi-threading Example", summary_prefix="Multi-threading"):
+        results = []
+        with concurrent.futures.ThreadPoolExecutor(max_workers=min(4, len(tasks))) as executor:
+            future_to_task = {executor.submit(worker, config, task_id): task_id for task_id in tasks}
+            for future in concurrent.futures.as_completed(future_to_task):
+                results.append(future.result())
+    print_results(results)
+
+
+def joblib_parallel_example(config: LeanREPLConfig, tasks: list[int]) -> None:
+    """Demonstrate joblib-based parallel execution with LeanInteract"""
+    with timed_section("Joblib Parallel Example", summary_prefix="Joblib parallel processing"):
+        results = Parallel(n_jobs=min(4, len(tasks)))(delayed(worker)(config, task_id) for task_id in tasks)
+    print_results(results)
+
+
+if __name__ == "__main__":
+    config, tasks = setup()
+
+    multiprocessing_example(config, tasks)
+    joblib_parallel_example(config, tasks)
+    multithreading_example(config, tasks)
+    sequential_baseline(config, tasks)

{lean_interact-0.9.2 → lean_interact-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lean-interact"
-version = "0.9.2"
+version = "0.10.0"
 description = "LeanInteract is a Python package that allows you to interact with the Lean theorem prover."
 keywords = ["Lean", "theorem proving", "autoformalization", "REPL"]
 license = { file = "LICENSE" }

{lean_interact-0.9.2 → lean_interact-0.10.0}/src/lean_interact/__init__.py

@@ -16,11 +16,14 @@ from lean_interact.project import (
     TempRequireProject,
 )
 from lean_interact.server import AutoLeanServer, LeanServer
+from lean_interact.sessioncache import PickleSessionCache, ReplaySessionCache
 
 __all__ = [
     "LeanREPLConfig",
     "LeanServer",
     "AutoLeanServer",
+    "PickleSessionCache",
+    "ReplaySessionCache",
     "LeanRequire",
     "GitProject",
     "LocalProject",

{lean_interact-0.9.2 → lean_interact-0.10.0}/src/lean_interact/server.py

@@ -33,7 +33,7 @@ from lean_interact.interface import (
     UnpickleEnvironment,
     UnpickleProofState,
 )
-from lean_interact.sessioncache import BaseSessionCache, PickleSessionCache
+from lean_interact.sessioncache import BaseSessionCache, ReplaySessionCache
 from lean_interact.utils import _limit_memory, get_total_memory_usage, logger
 
 DEFAULT_TIMEOUT: int | None = None
@@ -287,7 +287,7 @@ class LeanServer:
             raise ConnectionAbortedError(
                 f"The Lean server closed unexpectedly."
                 f"\n{'-' * 50}\nstdout:\n{stdout}\n{'-' * 50}\nstderr:\n{stderr}\n{'-' * 50}"
-                f"If stdout and stderr are empty or obscure, here is a list of possible reasons (not exhaustive):\n"
+                f"\nIf stdout and stderr are empty or obscure, here is a list of possible reasons (not exhaustive):\n"
                 "- Not enough memory and/or compute available\n"
                 "- The cached Lean REPL is corrupted. In this case, clear the cache using the `clear-lean-cache` command.\n"
                 "- An uncaught exception in the Lean REPL"
@@ -438,11 +438,11 @@ class AutoLeanServer(LeanServer):
             max_total_memory: The maximum proportion of system-wide memory usage (across all processes) before triggering a Lean server restart. This is a soft limit ranging from 0.0 to 1.0, with default 0.8 (80%). When system memory exceeds this threshold, the server restarts to free memory. Particularly useful in multiprocessing environments to prevent simultaneous crashes.
             max_process_memory: The maximum proportion of the memory hard limit (set in `LeanREPLConfig.memory_hard_limit_mb`) that the Lean server process can use before restarting. This soft limit ranges from 0.0 to 1.0, with default 0.8 (80%). Only applied if a hard limit is configured in `LeanREPLConfig`.
             max_restart_attempts: The maximum number of consecutive restart attempts allowed before raising a `MemoryError` exception. Default is 5. The server uses exponential backoff between restart attempts.
-            session_cache: The session cache to use, if specified.
+            session_cache: Optional session cache implementation. Defaults to `ReplaySessionCache()`.
+                Use `PickleSessionCache` if you explicitly need on-disk artifacts.
         """
-        session_cache = (
-            session_cache if session_cache is not None else PickleSessionCache(working_dir=config.working_dir)
-        )
+        if session_cache is None:
+            session_cache = ReplaySessionCache()
         self._session_cache: BaseSessionCache = session_cache
         self._max_total_memory = max_total_memory
         self._max_process_memory = max_process_memory
@@ -453,7 +453,7 @@ class AutoLeanServer(LeanServer):
         if state_id is None:
             return None
         if state_id in self._session_cache:
-            return self._session_cache[state_id].repl_id
+            return self._session_cache.get_repl_id(state_id, self)
         return state_id
 
     def restart(self, verbose: bool = False) -> None: