lean-interact 0.8.0__tar.gz → 0.8.2__tar.gz

{lean_interact-0.8.0 → lean_interact-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-interact
-Version: 0.8.0
+Version: 0.8.2
 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.7.0-rc1` and `v4.22.0-rc4`.
+- **🔧 Compatibility**: Supports all Lean versions between `v4.7.0-rc1` and `v4.23.0-rc2`.
   - 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.8.0 → lean_interact-0.8.2}/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.7.0-rc1` and `v4.22.0-rc4`.
+- **🔧 Compatibility**: Supports all Lean versions between `v4.7.0-rc1` and `v4.23.0-rc2`.
   - 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.8.0 → lean_interact-0.8.2}/docs/contributing.md

@@ -61,10 +61,12 @@ uv run mkdocs serve
 
 ## Reporting Issues & Getting Help
 
-- **Bugs/Feature requests:**
-  1. Check [GitHub issues](https://github.com/augustepoiroux/LeanInteract/issues) first (open or closed).
-  2. If new, open an issue with a clear description and steps to reproduce.
-- **Contact:** For questions, contact the [maintainer](mailto:auguste.poiroux@epfl.ch).
+**Bugs/Feature requests:**
+
+1. Check [GitHub issues](https://github.com/augustepoiroux/LeanInteract/issues) first (open or closed).
+2. If new, open an issue with a clear description and steps to reproduce.
+
+**Contact:** For questions, contact the [maintainer](mailto:auguste.poiroux@epfl.ch).
 
 ---
 

{lean_interact-0.8.0 → lean_interact-0.8.2}/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.7.0-rc1` and `v4.22.0-rc4`
+- **🔧 Compatibility**: Supports all Lean versions between `v4.7.0-rc1` and `v4.23.0-rc2`
     - 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)
@@ -30,7 +30,7 @@ hide:
 pip install lean-interact
 ```
 
-Install Lean 4 (if not already installed):
+Install Lean 4 (if not already installed) using the following command coming with LeanInteract:
 
 ```bash
 install-lean

{lean_interact-0.8.0 → lean_interact-0.8.2}/docs/user-guide/basic-usage.md

@@ -24,7 +24,7 @@ server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := id"))
 The response contains:
 
 - An environment state (`env`) that can be used for subsequent commands
-- Messages returned by Lean (errors, information, etc.)
+- Messages returned by Lean if any (errors, information, etc.)
 
 ### Working with Environment States
 
@@ -59,6 +59,7 @@ Both `Command` and `FileCommand` support several options:
 - `all_tactics`: Get information about tactics used
 - `root_goals`: Get information about goals in theorems and definitions
 - `infotree`: Get Lean infotree containing various informations about declarations and tactics
+- `env`: The environment from a previous command to be used as context. If `env = None`, starts from scratch.
 
 Example with options:
 
@@ -87,8 +88,6 @@ This response will include a list of `Sorry` objects, each containing:
 
 ## Error Handling
 
-It's good practice to handle errors that might occur during execution:
-
 ```python tags=["execute"]
 from lean_interact.interface import LeanError
 
@@ -104,8 +103,6 @@ except Exception as e:
 
 ## Next Steps
 
-Now that you understand basic operations, you can:
-
 - Learn about [tactic mode](tactic-mode.md) for step-by-step proof interaction
 - Configure [custom Lean environments](custom-lean-configuration.md)
 - Explore the [API Reference](../api/interface.md) for more command options

{lean_interact-0.8.0 → lean_interact-0.8.2}/docs/user-guide/custom-lean-configuration.md

@@ -14,11 +14,11 @@ config = LeanREPLConfig(lean_version="v4.7.0")
 server = LeanServer(config)
 ```
 
+## Working with Existing Projects
+
 !!! note
     When using a project through the `project` attribute, the Lean version is automatically inferred from the project. You cannot specify both `lean_version` and `project` parameters.
 
-## Working with Existing Projects
-
 ### Local Lean Projects
 
 To work with a local Lean project, create a `LocalProject` instance:
@@ -53,7 +53,7 @@ project = GitProject(
     url="https://github.com/yangky11/lean4-example",
     rev="main",  # Optional: specific branch, tag, or commit
     directory="/custom/cache/path",  # Optional: custom directory where the project will be cloned
-    force_pull=False  # Optional: force update from remote. Useful in case you already have the project cloned.
+    force_pull=False  # Optional: force update from remote. Useful in case you already have the project cloned and the branch has been updated.
 )
 config = LeanREPLConfig(project=project)
 server = LeanServer(config)
@@ -61,34 +61,16 @@ server = LeanServer(config)
 
 The `GitProject` will automatically:
 
-- Clone the repository if it doesn't exist
+- Clone the repository if it doesn't exist (including submodules if present)
 - Update to the specified revision
-- Build the project using Lake
-- Handle submodules if present
-
-### Using a Local REPL Installation
-
-If you're developing the Lean REPL or have a custom version, you can use your local copy instead of downloading from the Git repository:
-
-```python
-from lean_interact import LeanREPLConfig, LeanServer
-
-config = LeanREPLConfig(local_repl_path="path/to/your/local/repl", build_repl=True)
-server = LeanServer(config)
-```
-
-!!! note
-    When using `local_repl_path`, any specified `repl_rev`, and `repl_git` parameters are ignored as the local REPL is used directly.
-
-!!! note
-    You are responsible for using a compatible Lean version between your local REPL and the project you will interact with.
+- Build the project with `lake build`
 
 !!! tip
-    Setting `build_repl=False` will skip building the local REPL, which can be useful if you've already built it and want to avoid rebuilding.
+    Use the `directory` parameter to control where projects are cached
 
 ## Working with Temporary Projects
 
-LeanInteract allows you to create temporary projects with dependencies for experimentation without affecting your local environment.
+LeanInteract allows you to create temporary projects with dependencies for quick experimentation and automated reproducible setups.
 
 ### Simple Temporary Projects with Dependencies
 
@@ -151,7 +133,7 @@ Alternatively, you can define the lakefile content using the TOML format by sett
 
 ## Using Custom REPL Revisions
 
-LeanInteract uses a Lean REPL (Read-Eval-Print Loop) from a Git repository to interact with Lean. By default, it uses a specific version (`v1.0.9`) of the REPL from the default repository (`https://github.com/augustepoiroux/repl`). However, you can customize this by specifying a different REPL revision or repository:
+LeanInteract uses the Lean REPL from a git repository to interact with Lean. By default, it uses a specific version of the REPL from the default forked repository (`https://github.com/augustepoiroux/repl`) which manages compatibility with Lean versions. However, you can customize this by specifying a different REPL revision or repository:
 
 ```python
 from lean_interact import LeanREPLConfig, LeanServer
@@ -172,19 +154,29 @@ When you specify a `repl_rev`, LeanInteract will try to:
 
 This approach allows for better matching between REPL versions and Lean versions, ensuring compatibility.
 
-- Always check `config.is_setup()` before creating servers
 !!! warning
-    Custom/older REPL implementations may have interfaces that are incompatible with LeanInteract's standard commands. If you encounter issues, consider using the `run_dict` method from `LeanServer` to communicate directly with the REPL:
+    Custom/older REPL implementations may have interfaces that are incompatible with LeanInteract's current commands. If you encounter issues, consider using the `run_dict` method from `LeanServer` to communicate directly with the REPL:
 
     ```python
-    # Using run_dict instead of the standard commands
     result = server.run_dict({"cmd": "your_command_here"})
     ```
 
 !!! note
     The `repl_rev` and `repl_git` parameters are ignored if you specify `local_repl_path`.
 
-## Best Practices
+### Using a Local REPL Installation
+
+If you are developing the Lean REPL or have a custom version, you can use your local copy instead of downloading from a git repository:
+
+```python
+from lean_interact import LeanREPLConfig, LeanServer
+
+config = LeanREPLConfig(local_repl_path="path/to/your/local/repl", build_repl=True)
+server = LeanServer(config)
+```
+
+!!! note
+    When using `local_repl_path`, any specified `repl_rev`, and `repl_git` parameters are ignored as the local REPL is used directly.
 
-- **Custom Directories**: Use the `directory` parameter to control where projects are cached
-- **Build Control**: Use `auto_build=False` to skip building if you've already built a project
+!!! note
+    Make sure you are using a compatible Lean version between your local REPL and the project you will interact with.

{lean_interact-0.8.0 → lean_interact-0.8.2}/docs/user-guide/examples.md

@@ -4,7 +4,7 @@ execute: true
 
 # Examples
 
-This page provides practical examples of using LeanInteract in different scenarios. You can find the full examples in the [`examples`](https://github.com/augustepoiroux/LeanInteract/tree/main/examples) directory of the repository.
+This page provides practical examples of using LeanInteract in different scenarios. You can find a few full example scripts in the [`examples`](https://github.com/augustepoiroux/LeanInteract/tree/main/examples) directory of the repository.
 
 ## Basic Theorem Proving
 
@@ -77,11 +77,14 @@ print(result)  # Example raw output from the REPL
 
 For more comprehensive examples, check out the following scripts in the examples directory:
 
-1. [**proof_generation_and_autoformalization.py**](https://github.com/augustepoiroux/LeanInteract/blob/main/examples/proof_generation_and_autoformalization.py)  
+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.
+
+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.
 
-2. [**beq_plus.py**](https://github.com/augustepoiroux/LeanInteract/blob/main/examples/beq_plus.py)  
+3. [**beq_plus.py**](https://github.com/augustepoiroux/LeanInteract/blob/main/examples/beq_plus.py)  
    Demonstrates how to run the autoformalization BEq+ metric on the ProofNetVerif benchmark.
 
-3. [**type_check.py**](https://github.com/augustepoiroux/LeanInteract/blob/main/examples/type_check.py)  
+4. [**type_check.py**](https://github.com/augustepoiroux/LeanInteract/blob/main/examples/type_check.py)  
    Shows how to optimize type checking using environment states.

{lean_interact-0.8.0 → lean_interact-0.8.2}/docs/user-guide/getting-started.md

@@ -4,8 +4,6 @@ execute: true
 
 # Getting Started with LeanInteract
 
-This guide will help you take your first steps with LeanInteract and understand its core concepts.
-
 ## Overview
 
 LeanInteract provides a Python interface to the Lean 4 theorem prover via the Lean REPL (Read-Evaluate-Print Loop). It enables you to:
@@ -13,12 +11,9 @@ LeanInteract provides a Python interface to the Lean 4 theorem prover via the Le
 - Execute Lean code from Python
 - Process Lean files
 - Interact with proofs step by step
-- Save and restore proof states
 
 ## Quick Example
 
-Here's a minimal example to help you get started:
-
 ```python tags=["execute"]
 from lean_interact import LeanREPLConfig, LeanServer, Command
 
@@ -37,14 +32,12 @@ print(response)
 
 This will:
 
-1. Initialize a Lean REPL configuration
+1. Initialize a Lean REPL configuration: downloads and initializes the Lean environment
 2. Start a Lean server
 3. Execute a simple Lean theorem
 4. Return a response containing the Lean environment state and any messages
 
-## Understanding Core Components
-
-Let's break down the key components:
+## Core Components
 
 ### LeanREPLConfig
 
@@ -52,7 +45,7 @@ Let's break down the key components:
 
 ```python
 config = LeanREPLConfig(
-    lean_version="v4.19.0",  # Specify Lean version (optional)
+    lean_version="v4.19.0",  # Specify Lean version (optional, default is latest)
     verbose=True,            # Print detailed logs
 )
 ```
@@ -83,13 +76,11 @@ LeanInteract provides several types of commands:
 Basic command execution:
 
 ```python
-response = server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := id"))
+server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := id"))
 ```
 
 ## Next Steps
 
-Now that you understand the basics, you can:
-
 - Learn about [basic usage patterns](basic-usage.md)
 - Explore [tactic mode](tactic-mode.md) for step-by-step proof interaction
 - Configure [custom Lean environments](custom-lean-configuration.md)

{lean_interact-0.8.0 → lean_interact-0.8.2}/docs/user-guide/installation.md

@@ -26,13 +26,16 @@ pip install lean-interact
 
 ### 2. Install Lean 4 (if not already installed)
 
-LeanInteract provides a convenient command to install Lean 4 via the Elan version manager:
+LeanInteract provides a convenient command to install Lean 4 along with its official [Elan](https://github.com/leanprover/elan) version manager:
 
 ```
 install-lean
 ```
 
-This command will install Elan, which manages Lean versions. Your Elan version should be at least 4.0.0.
+This command will install Elan, which manages Lean versions.
+
+!!! warning "Elan Version"
+    Your Elan version should be at least 4.0.0.
 
 ## Verifying Installation
 
@@ -55,7 +58,7 @@ print(response)
 If everything is set up correctly, the script should output a successful response.
 
 !!! note
-    The first time you run LeanInteract, it might take some time as it downloads and builds Lean REPL. Subsequent runs will be significantly faster due to caching.
+    The first time you run LeanInteract, it might take some time as it downloads the requested Lean version and builds Lean REPL. Subsequent runs will be significantly faster due to caching.
 
 ## System-Specific Notes
 

lean_interact-0.8.2/docs/user-guide/multi-processing.md

@@ -0,0 +1,164 @@
+---
+execute: false
+---
+
+# Multi-processing Guide
+
+LeanInteract is designed with multi-processing in mind, allowing you to leverage multiple CPU cores for parallel theorem proving and verification tasks. This guide covers the best practices, patterns, and potential pitfalls when using LeanInteract in multi-process environments.
+
+We recommend using `AutoLeanServer`.
+It is specifically designed for multi-process 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, any feedback or issues encountered while using it are welcome.
+
+## Best Practices Summary
+
+1. **Always pre-instantiate** `LeanREPLConfig` before multiprocessing
+2. **One lean server per process**
+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
+
+Here is a minimal example of using LeanInteract with multiple processes:
+
+```python
+import multiprocessing as mp
+from lean_interact import LeanREPLConfig, AutoLeanServer, Command
+
+def worker(config: LeanREPLConfig, task_id):
+    """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 hasattr(result, 'messages') else 'Error'}"
+
+if __name__ == "__main__":
+    # Pre-instantiate config before multiprocessing
+    # LeanREPLConfig downloads and initializes resources
+    config = LeanREPLConfig(verbose=True)
+    
+    # Create processes
+    ctx = mp.get_context("spawn")
+    with ctx.Pool(processes=4) as pool:
+        tasks = range(5)
+        results = pool.starmap(worker, [(config, task_id) for task_id in tasks])
+        
+    for result in results:
+        print(result)
+```
+
+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 multiprocessing:
+
+```python
+from lean_interact import LeanREPLConfig, AutoLeanServer
+import multiprocessing as mp
+
+# ✅ CORRECT: Config created in main process
+def correct_approach():
+    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 incorrect_approach():
+    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
+
+Each process should have its own `LeanServer` or `AutoLeanServer` instance.
+
+```python
+def worker(config, task_data):
+    # Each process gets its own server
+    server = AutoLeanServer(config)
+    
+    # Process your tasks
+    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 within a single process thanks to internal locking mechanisms.
+All concurrent requests will be processed sequentially.
+
+### Across Processes
+
+Servers are **NOT** safe to share across processes. Each process must have its own server instance:
+
+```python
+import multiprocessing as mp
+from lean_interact import AutoLeanServer, LeanREPLConfig
+
+# ✅ CORRECT: Each process creates its own server
+def correct_multiprocess_worker(config: LeanREPLConfig, worker_id: int):
+    server = AutoLeanServer(config)  # New server per process
+    # ... work with server
+
+# ❌ INCORRECT: Don't share servers across processes
+def incorrect_multiprocess_pattern():
+    config = LeanREPLConfig()
+    server = AutoLeanServer(config)
+    
+    def worker(worker_id):
+        # This will cause issues - server can't be pickled/shared
+        result = server.run(Command(cmd="..."))
+    
+    with mp.Pool() as pool:
+        pool.map(worker, range(4))  # Will fail!
+```
+
+## 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 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.8.0 → lean_interact-0.8.2}/docs/user-guide/tactic-mode.md

@@ -7,7 +7,7 @@ execute: true
 Tactic mode in LeanInteract allows you to work with Lean's proof tactics step-by-step, providing an interactive way to develop and explore proofs.
 
 !!! warning "Experimental Feature"
-    The tactic mode feature is experimental in Lean REPL and may not work as expected in all situations. Some valid proofs might be incorrectly rejected. Please report any issues you encounter on the [Lean REPL GitHub repository](https://github.com/leanprover-community/repl/issues).
+    The tactic mode feature is experimental may not work as expected in all situations. Some valid proofs might be incorrectly rejected.
 
 ## Getting Started with Tactics
 
@@ -28,7 +28,7 @@ config = LeanREPLConfig()
 server = LeanServer(config)
 
 # Define a theorem with sorry
-response = server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := sorry"))
+response = server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := by sorry"))
 print(response.sorries[0])
 ```
 

{lean_interact-0.8.0 → lean_interact-0.8.2}/docs/user-guide/troubleshooting.md

@@ -19,7 +19,7 @@ This guide covers common issues you might encounter when using LeanInteract.
 
   ```python
   from lean_interact import AutoLeanServer, LeanREPLConfig
-  server = AutoLeanServer(LeanREPLConfig(memory_hard_limit_mb=1000)) # Limit to 1GB
+  server = AutoLeanServer(LeanREPLConfig(memory_hard_limit_mb=8192)) # Limit to 8GB
   ```
 
 - If you are working with large files or complex proofs in a single session, consider breaking them into smaller, more manageable pieces.

lean_interact-0.8.2/examples/multi_processing.py

@@ -0,0 +1,60 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["lean-interact"]
+# ///
+"""
+Example demonstrating multi-processing 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/multiprocessing_example.py
+"""
+
+import multiprocessing as mp
+
+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=f"#eval {task_id} * {task_id}"))
+        if isinstance(result, LeanError):
+            return f"Task {task_id}: LeanError - {result}"
+        return f"Task {task_id}: {task_id}² = {result.messages[0].data}"
+    except Exception as e:
+        return f"Task {task_id}: Exception - {e}"
+
+
+def main():
+    """Main function demonstrating correct multiprocessing setup"""
+    print("LeanInteract Multi-processing Example")
+    print("=" * 40)
+
+    # CRITICAL: Pre-instantiate config before multiprocessing as it downloads and initializes resources
+    print("Setting up LeanREPLConfig (may take a few minutes the first time)...")
+    config = LeanREPLConfig(verbose=True)
+    print("Config setup complete.")
+
+    # Dummy tasks
+    tasks = range(1, 6)
+    print(f"\nProcessing {len(tasks)} tasks in parallel...")
+
+    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("\nResults:")
+    print("-" * 40)
+    for result in results:
+        print(result)
+
+
+if __name__ == "__main__":
+    main()

{lean_interact-0.8.0 → lean_interact-0.8.2}/mkdocs.yml

@@ -143,6 +143,7 @@ nav:
       - Getting Started: user-guide/getting-started.md
       - Basic Usage: user-guide/basic-usage.md
       - Tactic Mode: user-guide/tactic-mode.md
+      - Multi-processing: user-guide/multi-processing.md
       - Examples: user-guide/examples.md
       - Custom Lean Configuration: user-guide/custom-lean-configuration.md
       - Troubleshooting: user-guide/troubleshooting.md

{lean_interact-0.8.0 → lean_interact-0.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lean-interact"
-version = "0.8.0"
+version = "0.8.2"
 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.8.0 → lean_interact-0.8.2}/src/lean_interact/utils.py

@@ -22,7 +22,7 @@ logger.addHandler(handler)
 ROOT_DIR = Path(__file__).resolve().parent
 DEFAULT_CACHE_DIR = ROOT_DIR / "cache"
 DEFAULT_REPL_GIT_URL = "https://github.com/augustepoiroux/repl"
-DEFAULT_REPL_VERSION = "v1.0.13"
+DEFAULT_REPL_VERSION = "v1.0.15"
 
 os.makedirs(DEFAULT_CACHE_DIR, exist_ok=True)
 

{lean_interact-0.8.0 → lean_interact-0.8.2}/tests/test_server.py

@@ -508,7 +508,7 @@ lean_exe "dummy" where
         with self.assertRaises(TimeoutError):
             server.run(
                 Command(
-                    cmd="theorem amc12a_2003_p1 (u v : ℕ → ℕ) (h₀ : ∀ n, u n = 2 * n + 2) (h₁ : ∀ n, v n = 2 * n + 1) :\n    ((∑ k in Finset.range 2003, u k) - ∑ k in Finset.range 2003, v k) = 2003 := by simp only [h₀, h₁, Finset.sum_range_succ, Finset.sum_range_zero]; rfl",
+                    cmd="def fib : Nat → Nat\n  | 0 => 0\n  | 1 => 1\n  | n + 2 => fib (n + 1) + fib n\n\n#eval fib 40",
                     env=root_env,
                 ),
                 timeout=2,

{lean_interact-0.8.0 → lean_interact-0.8.2}/uv.lock

@@ -561,7 +561,7 @@ wheels = [
 
 [[package]]
 name = "lean-interact"
-version = "0.8.0"
+version = "0.8.2"
 source = { editable = "." }
 dependencies = [
     { name = "filelock" },