lean-interact 0.3.2__tar.gz → 0.4.0__tar.gz

{lean_interact-0.3.2 → lean_interact-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-interact
-Version: 0.3.2
+Version: 0.4.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
@@ -37,16 +37,50 @@ Description-Content-Type: text/markdown
 
 # LeanInteract
 
+[![PyPI version](https://badge.fury.io/py/lean-interact.svg)](https://badge.fury.io/py/lean-interact)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 **LeanInteract** is a Python package designed to seamlessly interact with Lean 4 through the [Lean REPL](https://github.com/leanprover-community/repl).
 
 ## Key Features
 
 - **🔗 Interactivity**: Execute Lean code and files directly from Python.
 - **🚀 Ease of Use**: LeanInteract abstracts the complexities of Lean setup and interaction.
-- **🔧 Compatibility**: Supports all Lean versions between `v4.7.0-rc1` and `v4.18.0`.
+- **🔧 Compatibility**: Supports all Lean versions between `v4.7.0-rc1` and `v4.19.0-rc2`.
+  - We backport the latest features of Lean REPL to older versions of Lean.
 - **📦 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).
 
+## Table of Contents
+
+- [Key Features](#key-features)
+- [Installation and Setup](#installation-and-setup)
+- [Script examples](#script-examples)
+- [Usage](#usage)
+  - [Basic example](#basic-example)
+  - [Tactic mode](#tactic-mode)
+  - [Custom Lean configuration](#custom-lean-configuration)
+    - [Specific Lean version](#specific-lean-version)
+    - [Existing Lean projects](#existing-lean-projects)
+    - [Temporary project with dependencies](#temporary-project-with-dependencies)
+    - [Fine-grained temporary project](#fine-grained-temporary-project)
+- [Available Queries](#available-queries)
+  - [Command](#command)
+  - [FileCommand](#filecommand)
+  - [ProofStep](#proofstep)
+  - [Environment Pickling](#environment-pickling)
+  - [ProofState Pickling](#proofstate-pickling)
+- [Helper Commands](#helper-commands)
+- [Advanced options](#advanced-options)
+  - [LeanServer](#leanserver)
+  - [Custom Lean REPL](#custom-lean-repl)
+- [Similar tools](#similar-tools)
+- [Troubleshooting](#troubleshooting)
+- [Contributing](#contributing)
+- [Citation](#citation)
+- [License](#license)
+
 ## Installation and Setup
 
 You can install the LeanInteract package using the following command:
@@ -59,11 +93,7 @@ Requirements:
 
 - Python >= 3.10
 - git
-- [Lean 4](https://leanprover-community.github.io/get_started.html) (or use the `install-lean` command from LeanInteract)
-
-> [!NOTE]
-> This tool is still experimental and has been primarily tested on Linux. Compatibility with macOS is not guaranteed. For Windows, use WSL.
-> Please report any issues you encounter.
+- [Lean 4](https://leanprover-community.github.io/get_started.html) (Tip: use the `install-lean` command from LeanInteract)
 
 ## Script examples
 
@@ -72,11 +102,12 @@ In the `examples` directory, you will find a few scripts demonstrating how to us
 - `proof_generation_and_autoformalization.py`: use [DeepSeek-Prover-V1.5](https://arxiv.org/abs/2408.08152), [Goedel-Prover](https://goedel-lm.github.io/), and other models on [MiniF2F](https://github.com/yangky11/miniF2F-lean4) and [ProofNet#](https://huggingface.co/datasets/PAug/ProofNetSharp) benchmarks.
 - `beq_plus.py`: run the autoformalization [BEq+](https://arxiv.org/abs/2406.07222) metric on the [ProofNetVerif](https://huggingface.co/datasets/PAug/ProofNetVerif) benchmark.
 - `type_check.py`: optimize type checking using environment states.
-- `statement_autoformalization_sampling.py`: sampling-based method used in [Improving Autoformalization using Type Checking](https://arxiv.org/abs/2406.07222).
 
 ## Usage
 
-### Default Lean version (latest available)
+### Basic example
+
+The following code will use the default Lean version (latest available):
 
 ```python
 from lean_interact import LeanREPLConfig, LeanServer, Command
@@ -90,7 +121,15 @@ server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := id"))
 <summary>Output</summary>
 
 ```python
-CommandResponse(env=0)
+CommandResponse(
+  env=0,
+  messages=[
+    Message(start_pos=Pos(line=1, column=0),
+    end_pos=Pos(line=1, column=42),
+    data='Goals accomplished!',
+    severity='info')
+  ]
+)
 ```
 
 </details>
@@ -105,21 +144,116 @@ server.run(Command(cmd="example (x : Nat) : x = 5 → x = 5 := by exact ex x", e
 <summary>Output</summary>
 
 ```python
-CommandResponse(env=1)
+CommandResponse(
+  env=1,
+  messages=[
+    Message(start_pos=Pos(line=1, column=0),
+    end_pos=Pos(line=1, column=50),
+    data='Goals accomplished!',
+    severity='info')
+  ]
+)
 ```
 
 </details>
 
+See [Available Queries](#available-queries) for all available commands.
+
 > [!NOTE]
 > The initial invocation of `LeanREPLConfig` might take some time as it downloads and builds Lean REPL. Future executions with identical parameters will be significantly quicker due to caching.
 
-### Specific Lean version
+### Tactic mode
+
+> [!WARNING]
+> This feature is experimental in Lean REPL and may not work as expected: some valid proofs might be incorrectly rejected. Please report any issues you encounter [here](https://github.com/leanprover-community/repl/issues).
+
+First, let's run a command to create a theorem with a `sorry` proof:
+
+```python
+server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := sorry"))
+```
+
+<details>
+<summary>Output</summary>
+
+```python
+CommandResponse(
+  sorries=[
+    Sorry(start_pos=Pos(line=1, column=40),
+    end_pos=Pos(line=1, column=45),
+    goal='n : Nat\n⊢ n = 5 → n = 5',
+    proof_state=0)
+  ],
+  env=0,
+  messages=[
+    Message(start_pos=Pos(line=1, column=8),
+    end_pos=Pos(line=1, column=10),
+    data="declaration uses 'sorry'",
+    severity='warning')
+  ]
+)
+```
+
+</details>
+
+You can then iterate on the proof state by executing tactics:
+
+```python
+from lean_interact import ProofStep
+
+server.run(ProofStep(tactic="intro h", proof_state=0))
+```
+
+<details>
+<summary>Output</summary>
+
+```python
+ProofStepResponse(
+  proof_state=1,
+  goals=['n : Nat\nh : n = 5\n⊢ n = 5'],
+  proof_status='Incomplete: open goals remain'
+)
+```
+
+</details>
+
+```python
+server.run(ProofStep(tactic="exact h", proof_state=1))
+```
+
+<details>
+<summary>Output</summary>
+
+```python
+ProofStepResponse(proof_state=2, goals=[], proof_status='Completed')
+```
+
+</details>
+
+or by directly running the entire proof:
+
+```python
+server.run(ProofStep(tactic="(\nintro h\nexact h)", proof_state=0))
+```
+
+<details>
+<summary>Output</summary>
+
+```python
+ProofStepResponse(proof_state=3, goals=[], proof_status='Completed')
+```
+
+</details>
+
+### Custom Lean configuration
+
+#### Specific Lean version
 
 ```python
 config = LeanREPLConfig(lean_version="v4.7.0")
 ```
 
-### Existing Lean projects
+#### Existing Lean projects
 
 ```python
 config = LeanREPLConfig(project=LocalProject("path/to/your/project"))
@@ -143,7 +277,7 @@ server.run(FileCommand(path="file.lean"))
 > [!IMPORTANT]
 > Ensure the project can be *successfully* built with `lake build` before using LeanInteract.
 
-### Temporary project with dependencies
+#### Temporary project with dependencies
 
 ```python
 from lean_interact import TempRequireProject
@@ -175,21 +309,19 @@ theorem ex_mathlib (x : ℝ) (y : ℚ) :
 
 ```python
 CommandResponse(
-  messages=[
-    Message(
-      start_pos=Pos(line=2, column=8),
-      end_pos=Pos(line=2, column=18),
-      data="declaration uses 'sorry'",
-      severity='warning'
-  )],
+  env=0,
   sorries=[
-    Sorry(
-      start_pos=Pos(line=3, column=46),
-      end_pos=Pos(line=3, column=51),
-      goal='x : ℝ\ny : ℚ\n⊢ Irrational x → Irrational (x + ↑y)',
-      proof_state=0
-  )],
-  env=0
+    Sorry(end_pos=Pos(line=3, column=51),
+    goal='x : ℝ\ny : ℚ\n⊢ Irrational x → Irrational (x + ↑y)',
+    start_pos=Pos(line=3, column=46),
+    proof_state=0)
+  ],
+  messages=[
+    Message(end_pos=Pos(line=2, column=18),
+    data="declaration uses 'sorry'",
+    start_pos=Pos(line=2, column=8),
+    severity='warning')
+  ]
 )
 ```
 
@@ -200,7 +332,7 @@ CommandResponse(
 > - Mathlib is a large library and may take some time to download and build.
 > - A separate cache is used for each unique set of dependencies.
 
-### Fine-grained temporary project
+#### Fine-grained temporary project
 
 For more control over the temporary project, you can use `TemporaryProject` to specify the content of the lakefile.
 
@@ -223,79 +355,82 @@ require mathlib from git
 """))
 ```
 
-### Tactic mode (experimental)
+## Available Queries
 
-```python
-server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := sorry"))
-```
+LeanInteract supports various types of queries to interact with the Lean REPL. We briefly describe them in this section. You can check the file [interface.py](src/lean_interact/interface.py) for more details.
 
-<details>
-<summary>Output</summary>
+### Command
+
+Execute Lean code directly:
 
 ```python
-CommandResponse(
-  messages=[
-    Message(
-      start_pos=Pos(line=1, column=8),
-      end_pos=Pos(line=1, column=10),
-      data="declaration uses 'sorry'",
-      severity='warning'
-  )],
-  sorries=[
-    Sorry(
-      start_pos=Pos(line=1, column=40),
-      end_pos=Pos(line=1, column=45),
-      goal='n : Nat\n⊢ n = 5 → n = 5',
-      proof_state=0
-  )],
-  env=0
-)
-```
+from lean_interact import Command
 
-</details>
+# Execute a simple theorem
+response = server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := id"))
 
-You can then iterate on the proof state by executing tactics:
+# Execute with options to get tactics information
+response = server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := by simp", all_tactics=True))
 
-```python
-server.run(ProofStep(tactic="intro h", proof_state=0))
+# Continue in the same environment
+response = server.run(Command(cmd="#check ex", env=response.env))
 ```
 
-<details>
-<summary>Output</summary>
+### FileCommand
+
+Process Lean files:
 
 ```python
-ProofStepResponse(goals=['n : Nat\nh : n = 5\n⊢ n = 5'], proof_state=1)
-```
+from lean_interact import FileCommand
 
-</details>
+# Execute a Lean file
+response = server.run(FileCommand(path="myfile.lean"))
 
-```python
-server.run(ProofStep(tactic="exact h", proof_state=1))
+# With options for more information
+response = server.run(FileCommand(path="myfile.lean", root_goals=True))
 ```
 
-<details>
-<summary>Output</summary>
+### ProofStep
+
+Work with proof tactics step by step:
 
 ```python
-ProofStepResponse(goals=[], proof_state=2)
+from lean_interact import ProofStep
+
+# Apply a tactic to a proof state
+response = server.run(ProofStep(proof_state=0, tactic="intro h"))
+
+# Apply multiple tactics at once
+response = server.run(ProofStep(proof_state=0, tactic="intro h\nexact h"))
 ```
 
-</details>
+### Environment Pickling
 
-or by directly running the entire proof:
+Save and restore environment states:
 
 ```python
-server.run(ProofStep(tactic="(\nintro h\nexact h)", proof_state=0))
+from lean_interact import PickleEnvironment, UnpickleEnvironment
+
+# Save an environment
+server.run(PickleEnvironment(env=1, pickle_to="env_state.olean"))
+
+# Restore an environment
+server.run(UnpickleEnvironment(unpickle_env_from="env_state.olean"))
 ```
 
-<details>
-<summary>Output</summary>
+### ProofState Pickling
+
+Save and restore proof states:
 
 ```python
-ProofStepResponse(goals=[], proof_state=3)
-```
+from lean_interact import PickleProofState, UnpickleProofState
 
-</details>
+# Save a proof state
+server.run(PickleProofState(proof_state=2, pickle_to="proof_state.olean"))
+
+# Restore a proof state
+server.run(UnpickleProofState(unpickle_proof_state_from="proof_state.olean", env=1))
+```
 
 ## Helper Commands
 
@@ -333,3 +468,42 @@ We recommend checking out these tools:
 - **[leanclient](https://github.com/oOo0oOo/leanclient)**: Interact with the Lean LSP server.
 
 LeanInteract is inspired by **[pylean](https://github.com/zhangir-azerbayev/repl)** and **[lean4_jupyter](https://github.com/utensil/lean4_jupyter)**.
+
+## Troubleshooting
+
+Common issues and their solutions:
+
+1. **Out of memory errors**: Reduce parallel processing or increase system memory. Alternatively, use `AutoLeanServer` with conservative memory settings
+
+2. **Timeout errors**: Currently, `LeanServer` simply stops the Lean REPL if a command times out. Use `AutoLeanServer` for automatic recovery.
+
+3. **Long waiting times during first run**: This is expected as Lean REPL is being downloaded and built. Additionally, if you are importing Mathlib it will take even more time. Subsequent runs will be much faster.
+
+## Contributing
+
+Contributions are welcome! Here's how you can help:
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature-name`
+3. Commit your changes: `git commit -am 'Add new feature'`
+4. Push to the branch: `git push origin feature-name`
+5. Submit a pull request
+
+Please ensure your code includes appropriate tests.
+
+## Citation
+
+If you use LeanInteract in your research, please cite it as follows:
+
+```bibtex
+@software{leaninteract,
+  author = {Poiroux, Auguste},
+  title = {LeanInteract: A Python Interface for Lean 4},
+  url = {https://github.com/augustepoiroux/lean-interact},
+  year = {2025}
+}
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

{lean_interact-0.3.2 → lean_interact-0.4.0}/README.md

@@ -1,15 +1,49 @@
 # LeanInteract
 
+[![PyPI version](https://badge.fury.io/py/lean-interact.svg)](https://badge.fury.io/py/lean-interact)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 **LeanInteract** is a Python package designed to seamlessly interact with Lean 4 through the [Lean REPL](https://github.com/leanprover-community/repl).
 
 ## Key Features
 
 - **🔗 Interactivity**: Execute Lean code and files directly from Python.
 - **🚀 Ease of Use**: LeanInteract abstracts the complexities of Lean setup and interaction.
-- **🔧 Compatibility**: Supports all Lean versions between `v4.7.0-rc1` and `v4.18.0`.
+- **🔧 Compatibility**: Supports all Lean versions between `v4.7.0-rc1` and `v4.19.0-rc2`.
+  - We backport the latest features of Lean REPL to older versions of Lean.
 - **📦 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).
 
+## Table of Contents
+
+- [Key Features](#key-features)
+- [Installation and Setup](#installation-and-setup)
+- [Script examples](#script-examples)
+- [Usage](#usage)
+  - [Basic example](#basic-example)
+  - [Tactic mode](#tactic-mode)
+  - [Custom Lean configuration](#custom-lean-configuration)
+    - [Specific Lean version](#specific-lean-version)
+    - [Existing Lean projects](#existing-lean-projects)
+    - [Temporary project with dependencies](#temporary-project-with-dependencies)
+    - [Fine-grained temporary project](#fine-grained-temporary-project)
+- [Available Queries](#available-queries)
+  - [Command](#command)
+  - [FileCommand](#filecommand)
+  - [ProofStep](#proofstep)
+  - [Environment Pickling](#environment-pickling)
+  - [ProofState Pickling](#proofstate-pickling)
+- [Helper Commands](#helper-commands)
+- [Advanced options](#advanced-options)
+  - [LeanServer](#leanserver)
+  - [Custom Lean REPL](#custom-lean-repl)
+- [Similar tools](#similar-tools)
+- [Troubleshooting](#troubleshooting)
+- [Contributing](#contributing)
+- [Citation](#citation)
+- [License](#license)
+
 ## Installation and Setup
 
 You can install the LeanInteract package using the following command:
@@ -22,11 +56,7 @@ Requirements:
 
 - Python >= 3.10
 - git
-- [Lean 4](https://leanprover-community.github.io/get_started.html) (or use the `install-lean` command from LeanInteract)
-
-> [!NOTE]
-> This tool is still experimental and has been primarily tested on Linux. Compatibility with macOS is not guaranteed. For Windows, use WSL.
-> Please report any issues you encounter.
+- [Lean 4](https://leanprover-community.github.io/get_started.html) (Tip: use the `install-lean` command from LeanInteract)
 
 ## Script examples
 
@@ -35,11 +65,12 @@ In the `examples` directory, you will find a few scripts demonstrating how to us
 - `proof_generation_and_autoformalization.py`: use [DeepSeek-Prover-V1.5](https://arxiv.org/abs/2408.08152), [Goedel-Prover](https://goedel-lm.github.io/), and other models on [MiniF2F](https://github.com/yangky11/miniF2F-lean4) and [ProofNet#](https://huggingface.co/datasets/PAug/ProofNetSharp) benchmarks.
 - `beq_plus.py`: run the autoformalization [BEq+](https://arxiv.org/abs/2406.07222) metric on the [ProofNetVerif](https://huggingface.co/datasets/PAug/ProofNetVerif) benchmark.
 - `type_check.py`: optimize type checking using environment states.
-- `statement_autoformalization_sampling.py`: sampling-based method used in [Improving Autoformalization using Type Checking](https://arxiv.org/abs/2406.07222).
 
 ## Usage
 
-### Default Lean version (latest available)
+### Basic example
+
+The following code will use the default Lean version (latest available):
 
 ```python
 from lean_interact import LeanREPLConfig, LeanServer, Command
@@ -53,7 +84,15 @@ server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := id"))
 <summary>Output</summary>
 
 ```python
-CommandResponse(env=0)
+CommandResponse(
+  env=0,
+  messages=[
+    Message(start_pos=Pos(line=1, column=0),
+    end_pos=Pos(line=1, column=42),
+    data='Goals accomplished!',
+    severity='info')
+  ]
+)
 ```
 
 </details>
@@ -68,21 +107,116 @@ server.run(Command(cmd="example (x : Nat) : x = 5 → x = 5 := by exact ex x", e
 <summary>Output</summary>
 
 ```python
-CommandResponse(env=1)
+CommandResponse(
+  env=1,
+  messages=[
+    Message(start_pos=Pos(line=1, column=0),
+    end_pos=Pos(line=1, column=50),
+    data='Goals accomplished!',
+    severity='info')
+  ]
+)
 ```
 
 </details>
 
+See [Available Queries](#available-queries) for all available commands.
+
 > [!NOTE]
 > The initial invocation of `LeanREPLConfig` might take some time as it downloads and builds Lean REPL. Future executions with identical parameters will be significantly quicker due to caching.
 
-### Specific Lean version
+### Tactic mode
+
+> [!WARNING]
+> This feature is experimental in Lean REPL and may not work as expected: some valid proofs might be incorrectly rejected. Please report any issues you encounter [here](https://github.com/leanprover-community/repl/issues).
+
+First, let's run a command to create a theorem with a `sorry` proof:
+
+```python
+server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := sorry"))
+```
+
+<details>
+<summary>Output</summary>
+
+```python
+CommandResponse(
+  sorries=[
+    Sorry(start_pos=Pos(line=1, column=40),
+    end_pos=Pos(line=1, column=45),
+    goal='n : Nat\n⊢ n = 5 → n = 5',
+    proof_state=0)
+  ],
+  env=0,
+  messages=[
+    Message(start_pos=Pos(line=1, column=8),
+    end_pos=Pos(line=1, column=10),
+    data="declaration uses 'sorry'",
+    severity='warning')
+  ]
+)
+```
+
+</details>
+
+You can then iterate on the proof state by executing tactics:
+
+```python
+from lean_interact import ProofStep
+
+server.run(ProofStep(tactic="intro h", proof_state=0))
+```
+
+<details>
+<summary>Output</summary>
+
+```python
+ProofStepResponse(
+  proof_state=1,
+  goals=['n : Nat\nh : n = 5\n⊢ n = 5'],
+  proof_status='Incomplete: open goals remain'
+)
+```
+
+</details>
+
+```python
+server.run(ProofStep(tactic="exact h", proof_state=1))
+```
+
+<details>
+<summary>Output</summary>
+
+```python
+ProofStepResponse(proof_state=2, goals=[], proof_status='Completed')
+```
+
+</details>
+
+or by directly running the entire proof:
+
+```python
+server.run(ProofStep(tactic="(\nintro h\nexact h)", proof_state=0))
+```
+
+<details>
+<summary>Output</summary>
+
+```python
+ProofStepResponse(proof_state=3, goals=[], proof_status='Completed')
+```
+
+</details>
+
+### Custom Lean configuration
+
+#### Specific Lean version
 
 ```python
 config = LeanREPLConfig(lean_version="v4.7.0")
 ```
 
-### Existing Lean projects
+#### Existing Lean projects
 
 ```python
 config = LeanREPLConfig(project=LocalProject("path/to/your/project"))
@@ -106,7 +240,7 @@ server.run(FileCommand(path="file.lean"))
 > [!IMPORTANT]
 > Ensure the project can be *successfully* built with `lake build` before using LeanInteract.
 
-### Temporary project with dependencies
+#### Temporary project with dependencies
 
 ```python
 from lean_interact import TempRequireProject
@@ -138,21 +272,19 @@ theorem ex_mathlib (x : ℝ) (y : ℚ) :
 
 ```python
 CommandResponse(
-  messages=[
-    Message(
-      start_pos=Pos(line=2, column=8),
-      end_pos=Pos(line=2, column=18),
-      data="declaration uses 'sorry'",
-      severity='warning'
-  )],
+  env=0,
   sorries=[
-    Sorry(
-      start_pos=Pos(line=3, column=46),
-      end_pos=Pos(line=3, column=51),
-      goal='x : ℝ\ny : ℚ\n⊢ Irrational x → Irrational (x + ↑y)',
-      proof_state=0
-  )],
-  env=0
+    Sorry(end_pos=Pos(line=3, column=51),
+    goal='x : ℝ\ny : ℚ\n⊢ Irrational x → Irrational (x + ↑y)',
+    start_pos=Pos(line=3, column=46),
+    proof_state=0)
+  ],
+  messages=[
+    Message(end_pos=Pos(line=2, column=18),
+    data="declaration uses 'sorry'",
+    start_pos=Pos(line=2, column=8),
+    severity='warning')
+  ]
 )
 ```
 
@@ -163,7 +295,7 @@ CommandResponse(
 > - Mathlib is a large library and may take some time to download and build.
 > - A separate cache is used for each unique set of dependencies.
 
-### Fine-grained temporary project
+#### Fine-grained temporary project
 
 For more control over the temporary project, you can use `TemporaryProject` to specify the content of the lakefile.
 
@@ -186,79 +318,82 @@ require mathlib from git
 """))
 ```
 
-### Tactic mode (experimental)
+## Available Queries
 
-```python
-server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := sorry"))
-```
+LeanInteract supports various types of queries to interact with the Lean REPL. We briefly describe them in this section. You can check the file [interface.py](src/lean_interact/interface.py) for more details.
 
-<details>
-<summary>Output</summary>
+### Command
+
+Execute Lean code directly:
 
 ```python
-CommandResponse(
-  messages=[
-    Message(
-      start_pos=Pos(line=1, column=8),
-      end_pos=Pos(line=1, column=10),
-      data="declaration uses 'sorry'",
-      severity='warning'
-  )],
-  sorries=[
-    Sorry(
-      start_pos=Pos(line=1, column=40),
-      end_pos=Pos(line=1, column=45),
-      goal='n : Nat\n⊢ n = 5 → n = 5',
-      proof_state=0
-  )],
-  env=0
-)
-```
+from lean_interact import Command
 
-</details>
+# Execute a simple theorem
+response = server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := id"))
 
-You can then iterate on the proof state by executing tactics:
+# Execute with options to get tactics information
+response = server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := by simp", all_tactics=True))
 
-```python
-server.run(ProofStep(tactic="intro h", proof_state=0))
+# Continue in the same environment
+response = server.run(Command(cmd="#check ex", env=response.env))
 ```
 
-<details>
-<summary>Output</summary>
+### FileCommand
+
+Process Lean files:
 
 ```python
-ProofStepResponse(goals=['n : Nat\nh : n = 5\n⊢ n = 5'], proof_state=1)
-```
+from lean_interact import FileCommand
 
-</details>
+# Execute a Lean file
+response = server.run(FileCommand(path="myfile.lean"))
 
-```python
-server.run(ProofStep(tactic="exact h", proof_state=1))
+# With options for more information
+response = server.run(FileCommand(path="myfile.lean", root_goals=True))
 ```
 
-<details>
-<summary>Output</summary>
+### ProofStep
+
+Work with proof tactics step by step:
 
 ```python
-ProofStepResponse(goals=[], proof_state=2)
+from lean_interact import ProofStep
+
+# Apply a tactic to a proof state
+response = server.run(ProofStep(proof_state=0, tactic="intro h"))
+
+# Apply multiple tactics at once
+response = server.run(ProofStep(proof_state=0, tactic="intro h\nexact h"))
 ```
 
-</details>
+### Environment Pickling
 
-or by directly running the entire proof:
+Save and restore environment states:
 
 ```python
-server.run(ProofStep(tactic="(\nintro h\nexact h)", proof_state=0))
+from lean_interact import PickleEnvironment, UnpickleEnvironment
+
+# Save an environment
+server.run(PickleEnvironment(env=1, pickle_to="env_state.olean"))
+
+# Restore an environment
+server.run(UnpickleEnvironment(unpickle_env_from="env_state.olean"))
 ```
 
-<details>
-<summary>Output</summary>
+### ProofState Pickling
+
+Save and restore proof states:
 
 ```python
-ProofStepResponse(goals=[], proof_state=3)
-```
+from lean_interact import PickleProofState, UnpickleProofState
 
-</details>
+# Save a proof state
+server.run(PickleProofState(proof_state=2, pickle_to="proof_state.olean"))
+
+# Restore a proof state
+server.run(UnpickleProofState(unpickle_proof_state_from="proof_state.olean", env=1))
+```
 
 ## Helper Commands
 
@@ -296,3 +431,42 @@ We recommend checking out these tools:
 - **[leanclient](https://github.com/oOo0oOo/leanclient)**: Interact with the Lean LSP server.
 
 LeanInteract is inspired by **[pylean](https://github.com/zhangir-azerbayev/repl)** and **[lean4_jupyter](https://github.com/utensil/lean4_jupyter)**.
+
+## Troubleshooting
+
+Common issues and their solutions:
+
+1. **Out of memory errors**: Reduce parallel processing or increase system memory. Alternatively, use `AutoLeanServer` with conservative memory settings
+
+2. **Timeout errors**: Currently, `LeanServer` simply stops the Lean REPL if a command times out. Use `AutoLeanServer` for automatic recovery.
+
+3. **Long waiting times during first run**: This is expected as Lean REPL is being downloaded and built. Additionally, if you are importing Mathlib it will take even more time. Subsequent runs will be much faster.
+
+## Contributing
+
+Contributions are welcome! Here's how you can help:
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature-name`
+3. Commit your changes: `git commit -am 'Add new feature'`
+4. Push to the branch: `git push origin feature-name`
+5. Submit a pull request
+
+Please ensure your code includes appropriate tests.
+
+## Citation
+
+If you use LeanInteract in your research, please cite it as follows:
+
+```bibtex
+@software{leaninteract,
+  author = {Poiroux, Auguste},
+  title = {LeanInteract: A Python Interface for Lean 4},
+  url = {https://github.com/augustepoiroux/lean-interact},
+  year = {2025}
+}
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

{lean_interact-0.3.2 → lean_interact-0.4.0}/examples/beq_plus.py

@@ -2,7 +2,7 @@
 # requires-python = ">=3.10"
 # dependencies = [
 #     "datasets",
-#     "lean-interact @ file:///home/poiroux/Documents/EPFL/PhD/Lean/LeanInteract",
+#     "lean-interact",
 #     "rich",
 #     "tqdm",
 #     "scikit-learn",

{lean_interact-0.3.2 → lean_interact-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lean-interact"
-version = "0.3.2"
+version = "0.4.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.3.2 → lean_interact-0.4.0}/src/lean_interact/interface.py

@@ -28,39 +28,93 @@ class BaseREPLQuery(REPLBaseModel):
 
 
 class CommandOptions(REPLBaseModel):
+    """Options for commands.
+    Attributes:
+        all_tactics: If true, return all tactics used in the command with their associated information.
+        root_goals: If true, return root goals, i.e. initial goals of all declarations in the command, even if they already have a proof.
+        infotree: Return syntax information. Should be "full", "tactics", "original", or "substantive". Anything else is ignored.
+    """
+
     all_tactics: Annotated[bool | None, Field(alias="allTactics")] = None
+    root_goals: Annotated[bool | None, Field(alias="rootGoals")] = None
     infotree: str | None = None
 
 
 class Command(BaseREPLQuery, CommandOptions):
+    """Command to be executed in the REPL.
+    Attributes:
+        cmd: The command to be executed.
+        env: The environment to be used (optional). If `env = None`, starts a new session (in which you can use `import`).
+            If `env` is set, the command is executed in the given environment.
+        all_tactics: If true, return all tactics used in the command with their associated information.
+        root_goals: If true, return root goals, i.e. initial goals of all declarations in the command, even if they already have a proof.
+        infotree: Return syntax information. Should be "full", "tactics", "original", or "substantive". Anything else is ignored.
+    """
+
     cmd: Annotated[str, Field(min_length=1)]
     env: int | None = None
 
 
 class FileCommand(BaseREPLQuery, CommandOptions):
+    """Command for file operations in the REPL.
+    Attributes:
+        path: The path of the file to be operated on.
+        all_tactics: If true, return all tactics used in the command with their associated information.
+        root_goals: If true, return root goals, i.e. initial goals of all declarations in the command, even if they already have a proof.
+        infotree: Return syntax information. Should be "full", "tactics", "original", or "substantive". Anything else is ignored.
+    """
+
     path: Annotated[str, Field(min_length=1)]
 
 
 class ProofStep(BaseREPLQuery, REPLBaseModel):
+    """Proof step in the REPL.
+    Attributes:
+        proof_state: The proof state to start from.
+        tactic: The tactic to be applied.
+    """
+
     proof_state: Annotated[int, Field(alias="proofState")]
     tactic: Annotated[str, Field(min_length=1)]
 
 
 class PickleEnvironment(BaseREPLQuery):
+    """Environment for pickling in the REPL.
+    Attributes:
+        env: The environment to be used.
+        pickle_to: The path to save the pickle file.
+    """
+
     env: int
     pickle_to: Annotated[str, Field(min_length=1, alias="pickleTo")]
 
 
 class UnpickleEnvironment(BaseREPLQuery):
+    """Environment for unpickling in the REPL.
+    Attributes:
+        unpickle_env_from: The path to the pickle file.
+    """
+
     unpickle_env_from: Annotated[str, Field(min_length=1, alias="unpickleEnvFrom")]
 
 
 class PickleProofState(BaseREPLQuery):
+    """Proof state for pickling in the REPL.
+    Attributes:
+        proof_state: The proof state to be pickled.
+        pickle_to: The path to save the pickle file.
+    """
+
     proof_state: Annotated[int, Field(alias="proofState")]
     pickle_to: Annotated[str, Field(min_length=1, alias="pickleTo")]
 
 
 class UnpickleProofState(BaseREPLQuery):
+    """Environment for unpickling in the REPL.
+    Attributes:
+        unpickle_proof_state_from: The path to the pickle file.
+    """
+
     unpickle_proof_state_from: Annotated[str, Field(min_length=1, alias="unpickleProofStateFrom")]
     env: int | None = None
 
@@ -84,6 +138,14 @@ class Pos(REPLBaseModel):
 
 
 class Message(REPLBaseModel):
+    """Message in the REPL.
+    Attributes:
+        start_pos: The starting position of the message.
+        end_pos: The ending position of the message.
+        severity: The severity of the message.
+        data: The data associated with the message.
+    """
+
     start_pos: Annotated[Pos, Field(alias="pos")]
     end_pos: Annotated[Pos | None, Field(alias="endPos")] = None
     severity: Literal["error", "warning", "info", "trace"]
@@ -91,6 +153,14 @@ class Message(REPLBaseModel):
 
 
 class Sorry(REPLBaseModel):
+    """Sorry message in the REPL.
+    Attributes:
+        start_pos: The starting position of the sorry message.
+        end_pos: The ending position of the sorry message.
+        goal: The proof goal at the sorry location.
+        proof_state: The proof state associated to the sorry.
+    """
+
     start_pos: Annotated[Pos, Field(alias="pos")]
     end_pos: Annotated[Pos, Field(alias="endPos")]
     goal: str
@@ -98,6 +168,16 @@ class Sorry(REPLBaseModel):
 
 
 class Tactic(REPLBaseModel):
+    """Tactic in the REPL.
+    Attributes:
+        start_pos: The starting position of the tactic.
+        end_pos: The ending position of the tactic.
+        goals: The goals associated with the tactic.
+        tactic: The applied tactic.
+        proof_state: The proof state associated with the tactic.
+        used_constants: The constants used in the tactic.
+    """
+
     start_pos: Annotated[Pos, Field(alias="pos")]
     end_pos: Annotated[Pos, Field(alias="endPos")]
     goals: str
@@ -119,6 +199,12 @@ def message_intersects_code(msg: Message | Sorry, start_pos: Pos | None, end_pos
 
 
 class BaseREPLResponse(REPLBaseModel):
+    """Base class for all Lean responses.
+    Attributes:
+        messages: List of messages in the response.
+        sorries: List of sorries found in the submitted code.
+    """
+
     messages: list[Message] = Field(default_factory=list)
     sorries: list[Sorry] = Field(default_factory=list)
 
@@ -157,12 +243,32 @@ class BaseREPLResponse(REPLBaseModel):
 
 
 class CommandResponse(BaseREPLResponse):
+    """Response to a command in the REPL.
+    Attributes:
+        env: The environment state after running the code in the command
+        tactics: List of tactics in the code. Returned only if `all_tactics` is true.
+        infotree: The infotree of the code. Returned only if `infotree` is true.
+        messages: List of messages in the response.
+        sorries: List of sorries found in the submitted code.
+    """
+
     env: int
     tactics: list[Tactic] = Field(default_factory=list)
     infotree: dict | None = None
 
 
 class ProofStepResponse(BaseREPLResponse):
+    """Response to a proof step in the REPL.
+    Attributes:
+        proof_status: The proof status of the whole proof. Possible values: `Completed`, `Incomplete`, `Error`.
+        proof_state: The proof state after the proof step.
+        goals: List of goals after the proof step.
+        traces: List of traces in the proof step.
+        messages: List of messages in the response.
+        sorries: List of sorries found in the submitted code.
+    """
+
+    proof_status: Annotated[str, Field(alias="proofStatus")]
     proof_state: Annotated[int, Field(alias="proofState")]
     goals: list[str] = Field(default_factory=list)
     traces: list[str] = Field(default_factory=list)

{lean_interact-0.3.2 → lean_interact-0.4.0}/src/lean_interact/server.py

@@ -90,17 +90,17 @@ class LeanServer:
         assert self._proc is not None
         if verbose:
             logger.info("Sending query: %s", json_query)
-        self._proc.sendline(json_query)
-        self._proc.sendline()
-        _ = self._proc.expect_exact("\r\n\r\n", timeout=timeout)
+        self._proc.send(json_query + "\n\n")
+        self._proc.expect_exact("\r\n\r\n", timeout=timeout)
         return self._proc.before or ""
 
     def _parse_repl_output(self, raw_output: str, verbose: bool) -> dict:
         """Clean up raw REPL output and parse JSON response."""
+        if verbose:
+            logger.info("Server raw output: `%s", raw_output)
         output = raw_output.replace("\r\n", "\n")
         output = output[output.find('{"') :] if '{"' in output else ""
         if verbose:
-            logger.info("Server raw output: `%s", raw_output)
             logger.info("Server cleaned output: `%s", output)
         try:
             return json.loads(output)

{lean_interact-0.3.2 → lean_interact-0.4.0}/src/lean_interact/utils.py

@@ -21,7 +21,7 @@ logger.addHandler(handler)
 ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
 DEFAULT_CACHE_DIR = os.path.join(ROOT_DIR, "cache")
 DEFAULT_REPL_GIT_URL = "https://github.com/augustepoiroux/repl"
-DEFAULT_REPL_VERSION = "v1.0.4"
+DEFAULT_REPL_VERSION = "v1.0.6"
 
 os.makedirs(DEFAULT_CACHE_DIR, exist_ok=True)
 

{lean_interact-0.3.2 → lean_interact-0.4.0}/tests/test_server.py

@@ -139,7 +139,7 @@ class TestLeanServer(unittest.TestCase):
             ),
         )
         tactic_result = server.run(ProofStep(tactic="rfl", proof_state=0))
-        self.assertEqual(tactic_result, ProofStepResponse(proof_state=1, goals=[]))
+        self.assertEqual(tactic_result, ProofStepResponse(proof_state=1, goals=[], proof_status="Completed"))
 
     def test_run_file_nonexistent(self):
         server = AutoLeanServer(config=LeanREPLConfig(verbose=True))
@@ -197,14 +197,7 @@ class TestLeanServer(unittest.TestCase):
             ),
         )
         result = server.run(ProofStep(tactic="rfl", proof_state=0))
-        self.assertEqual(result, ProofStepResponse(proof_state=1, goals=[]))
-
-    def test_run_multiple_commands(self):
-        server = AutoLeanServer(config=LeanREPLConfig(memory_hard_limit_mb=4096, verbose=True))
-
-        for i in range(100):
-            cmd = Command(cmd=f"theorem womp{i} (a{i} b c : Nat) : (a{i} + b) + c = c + a{i} + b := by sorry")
-            server.run(cmd)
+        self.assertEqual(result, ProofStepResponse(proof_state=1, goals=[], proof_status="Completed"))
 
     def test_lean_version(self):
         server = AutoLeanServer(config=LeanREPLConfig(lean_version="v4.14.0", verbose=True))
@@ -258,7 +251,7 @@ class TestLeanServer(unittest.TestCase):
             ),
         )
         result = server.run(ProofStep(tactic="apply irrational_add_rat_iff.mpr", proof_state=0))
-        self.assertEqual(result, ProofStepResponse(proof_state=1, goals=[]))
+        self.assertEqual(result, ProofStepResponse(proof_state=1, goals=[], proof_status="Completed"))
 
     def test_restart_with_env(self):
         server = AutoLeanServer(config=LeanREPLConfig(verbose=True))
@@ -298,12 +291,12 @@ class TestLeanServer(unittest.TestCase):
         # Prepare restart_persistent_session_cache
         server._restart_persistent_session_cache[-2] = _SessionState(-2, 20, "", True)
         with unittest.mock.patch.object(server, "_get_repl_state_id", return_value=20):
-            mock_super.return_value = {"proofState": 20}
+            mock_super.return_value = {"proofState": 20, "goals": [], "proofStatus": "Completed"}
             result = server.run(ProofStep(proof_state=-2, tactic="test"))
             mock_super.assert_called_with(
                 request={"proofState": 20, "tactic": "test"}, verbose=False, timeout=DEFAULT_TIMEOUT
             )
-            self.assertEqual(result, ProofStepResponse(proof_state=20, goals=[]))
+            self.assertEqual(result, ProofStepResponse(proof_state=20, goals=[], proof_status="Completed"))
 
     @unittest.mock.patch("lean_interact.server.LeanServer.run_dict", return_value={})
     @unittest.mock.patch("lean_interact.server.psutil.virtual_memory")
@@ -409,13 +402,23 @@ class TestLeanServer(unittest.TestCase):
         step1 = server.run(ProofStep(tactic="intro x", proof_state=0))
         assert not isinstance(step1, LeanError)
         step2 = server.run(ProofStep(tactic="rfl", proof_state=step1.proof_state))
-        self.assertEqual(step2, ProofStepResponse(proof_state=2, goals=[]))
+        self.assertEqual(step2, ProofStepResponse(proof_state=2, goals=[], proof_status="Completed"))
+
+    def test_run_multiple_commands(self):
+        # Test this issue: https://github.com/leanprover-community/repl/issues/77
+        server = AutoLeanServer(config=LeanREPLConfig(memory_hard_limit_mb=4096, verbose=True))
+
+        with self.assertRaises(ConnectionAbortedError):
+            for i in range(1000):
+                cmd = Command(cmd=f"theorem womp{i} (a{i} b c : Nat) : (a{i} + b) + c = c + a{i} + b := by sorry")
+                server.run(cmd)
 
     def test_run_lots_of_commands(self):
+        # Test this issue: https://github.com/leanprover-community/repl/issues/77
         server = LeanServer(LeanREPLConfig(verbose=True))
 
         init_env = server.run(Command(cmd="#eval 1"))
-        assert isinstance(init_env, CommandResponse)
+        assert not isinstance(init_env, LeanError)
         for i in range(1000):
             cmd = Command(
                 cmd=f"theorem womp{i} (a{i} b c : Nat) : (a{i} + b) + c = c + a{i} + b := by sorry", env=init_env.env
@@ -543,7 +546,7 @@ class TestLeanServer(unittest.TestCase):
 
         # Test that we can continue the proof from the unpickled proof state
         tactic_result = new_server.run(ProofStep(tactic="rfl", proof_state=unpickled_proof_state_id))
-        self.assertEqual(tactic_result, ProofStepResponse(proof_state=1, goals=[]))
+        self.assertEqual(tactic_result, ProofStepResponse(proof_state=1, goals=[], proof_status="Completed"))
 
     def test_pickle_fails_with_invalid_env(self):
         server = AutoLeanServer(config=LeanREPLConfig(verbose=True))