lean-interact 0.10.4__tar.gz → 0.11.0__tar.gz

{lean_interact-0.10.4 → lean_interact-0.11.0}/.github/workflows/ci.yml

@@ -25,6 +25,18 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v3
 
+      - name: Free Disk Space (Ubuntu)
+        if: runner.os == 'Linux'
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: false
+          android: true
+          dotnet: true
+          haskell: true
+          large-packages: true
+          docker-images: true
+          swap-storage: true
+
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v4
         with:

{lean_interact-0.10.4 → lean_interact-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-interact
-Version: 0.10.4
+Version: 0.11.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
@@ -34,6 +34,7 @@ Requires-Dist: psutil>=6.1.0
 Requires-Dist: pydantic>=2.11.1
 Requires-Dist: requests>=2.32.3
 Requires-Dist: rich>=13.9.4
+Requires-Dist: tqdm>=4.67.1
 Description-Content-Type: text/markdown
 
 # LeanInteract
@@ -53,7 +54,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.26.0-rc2`.
+- **🔧 Compatibility**: Supports all Lean versions between `v4.8.0-rc1` and `v4.28.0-rc1`.
   - 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.10.4 → lean_interact-0.11.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.26.0-rc2`.
+- **🔧 Compatibility**: Supports all Lean versions between `v4.8.0-rc1` and `v4.28.0-rc1`.
   - 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.11.0/docs/api/pool.md

@@ -0,0 +1,7 @@
+::: lean_interact.pool
+    options:
+      heading_level: 1
+      heading: "Server Pool"
+      show_symbol_type_heading: false
+      members:
+        - LeanServerPool

lean_interact-0.11.0/docs/api/server.md

@@ -0,0 +1,20 @@
+::: lean_interact.server
+    options:
+      heading_level: 1
+      heading: "Lean Servers"
+      show_symbol_type_heading: false
+      members:
+        - LeanServer
+        - AutoLeanServer
+
+---
+
+## Notes on performance features
+
+LeanInteract automatically augments [`Command`](interface.md#lean_interact.interface.Command) and [`FileCommand`](interface.md#lean_interact.interface.FileCommand) requests to speed up elaboration and processing of files:
+
+- Incremental elaboration is enabled by default
+- Parallel elaboration is enabled via `set_option Elab.async true` by default when supported (Lean >= v4.19.0)
+
+These behaviors can be disabled in [`LeanREPLConfig`](config.md#lean_interact.config.LeanREPLConfig) by setting
+[`enable_incremental_optimization`](config.md#lean_interact.config.LeanREPLConfig.enable_incremental_optimization) to `False` and/or [`enable_parallel_elaboration`](config.md#lean_interact.config.LeanREPLConfig.enable_parallel_elaboration) to `False`.

{lean_interact-0.10.4 → lean_interact-0.11.0}/docs/contributing.md

@@ -5,19 +5,19 @@ hide:
 
 # Contributing to LeanInteract
 
-Thank you for your interest in contributing to LeanInteract! This guide will help you get started, follow best practices, and make your contributions easy to review.
+Thank you for contributing to LeanInteract! This guide will help getting started, following best practices, and making contributions easy to review.
 
 ## Pull Request Guidelines
 
-- **Describe your changes** clearly and concisely in the PR description.
+- **Describe changes** clearly and concisely in the PR description.
 - **Link to relevant issues** using `#` (e.g., #42).
 - **Include tests** for new features or bug fixes.
-- **Update documentation** if your change affects usage or APIs.
+- **Update documentation** if changes affect usage or APIs.
 - **Ensure all tests pass** before requesting review.
 
 ## Getting Started
 
-1. **Fork the repository** on GitHub and clone your fork locally.
+1. **Fork the repository** on GitHub and clone the fork locally.
 
 2. **Install development dependencies**: we recommend using [uv](https://docs.astral.sh/uv/).
 

{lean_interact-0.10.4 → lean_interact-0.11.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.26.0-rc2`
+- **🔧 Compatibility**: Supports all Lean versions between `v4.8.0-rc1` and `v4.28.0-rc1`
     - 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)
@@ -38,7 +38,7 @@ Install Lean 4 (if not already installed) using the following command coming wit
 install-lean
 ```
 
-### Start using it in your Python scripts
+### Start using it in Python scripts
 
 ```python
 from lean_interact import LeanREPLConfig, LeanServer, Command

{lean_interact-0.10.4 → lean_interact-0.11.0}/docs/user-guide/basic-usage.md

@@ -4,7 +4,7 @@ This guide covers the fundamental operations and command types in LeanInteract.
 
 ## Basic Command Execution
 
-The most common operation in LeanInteract is executing Lean code directly using the `Command` class:
+The most common operation in LeanInteract is executing Lean code directly using the [`Command`](../api/interface.md#lean_interact.interface.Command) class:
 
 ```python exec="on" source="above" session="base" result="python"
 from lean_interact import LeanREPLConfig, LeanServer, Command
@@ -20,11 +20,11 @@ print(server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := id")))
 The response contains:
 
 - Messages returned by Lean if any (errors, information, etc.)
-- An environment state (`env`) that can be used for subsequent commands.
+- An environment state ([`env`](../api/interface.md#lean_interact.interface.CommandResponse.env)) that can be used for subsequent commands.
 
 ### Working with Environment States
 
-Each command execution creates a new environment state. You can use this state in subsequent commands:
+Each command execution creates a new environment state. Use this state in subsequent commands:
 
 ```python exec="on" source="above" session="base" result="python"
 # First command creates environment state
@@ -36,7 +36,7 @@ print(server.run(Command(cmd="#check x", env=response1.env)))
 
 ## Processing Lean Files
 
-You can process entire Lean files using the `FileCommand` class:
+Process entire Lean files using the [`FileCommand`](../api/interface.md#lean_interact.interface.FileCommand) class:
 
 ```python
 from lean_interact import FileCommand
@@ -50,15 +50,15 @@ response = server.run(FileCommand(path="myfile.lean", root_goals=True))
 
 ## Available Options
 
-Both `Command` and `FileCommand` support several options:
+Both [`Command`](../api/interface.md#lean_interact.interface.Command) and [`FileCommand`](../api/interface.md#lean_interact.interface.FileCommand) support several options:
 
-- `all_tactics`: Get information about tactics used
-- `declarations`: Extract fine-grained information about declarations in the code
-- `root_goals`: Get information about goals in theorems and definitions
-- `infotree`: Get Lean infotree containing various informations from the Lean syntax tree
-- `incrementality`: Enable or disable incremental elaboration for this specific command.
-- `set_options`: Set Lean options for this command (see [Set Options](set-options.md))
-- `env`: The environment from a previous command to be used as context. If `env = None`, starts from scratch.
+- [`all_tactics`](../api/interface.md#lean_interact.interface.Command.all_tactics): Get information about tactics used
+- [`declarations`](../api/interface.md#lean_interact.interface.Command.declarations): Extract fine-grained information about declarations in the code
+- [`root_goals`](../api/interface.md#lean_interact.interface.Command.root_goals): Get information about goals in theorems and definitions
+- [`infotree`](../api/interface.md#lean_interact.interface.Command.infotree): Get Lean infotree containing various informations from the Lean syntax tree
+- [`incrementality`](../api/interface.md#lean_interact.interface.Command.incrementality): Enable or disable incremental elaboration for this specific command.
+- [`set_options`](../api/interface.md#lean_interact.interface.Command.set_options): Set Lean options for this command (see [Set Options](set-options.md))
+- [`env`](../api/interface.md#lean_interact.interface.Command.env): The environment from a previous command to be used as context. If `env = None`, starts from scratch.
 
 Example with options:
 
@@ -79,11 +79,11 @@ response = server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := sor
 print(response.sorries[0])
 ```
 
-This response will include a list of `Sorry` objects, each containing:
+This response will include a list of [`Sorry`](../api/interface.md#lean_interact.interface.Sorry) objects, each containing:
 
 - Position in the code
 - Goal to be proven
-- Proof state ID (can be used with `ProofStep` commands)
+- Proof state ID ([`proof_state`](../api/interface.md#lean_interact.interface.Sorry.proof_state)) (can be used with [`ProofStep`](../api/interface.md#lean_interact.interface.ProofStep) commands)
 
 ## Error Handling
 

{lean_interact-0.10.4 → lean_interact-0.11.0}/docs/user-guide/custom-lean-configuration.md

@@ -4,7 +4,7 @@ LeanInteract provides flexible ways to configure the Lean environment to suit di
 
 ## Specifying Lean Versions
 
-You can specify which version of Lean 4 you want to use when no project is specified:
+Specify which version of Lean 4 to use when no project is specified:
 
 ```python
 from lean_interact import LeanREPLConfig, LeanServer
@@ -17,18 +17,18 @@ 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.
+    When using a project through the [`project`](../api/config.md#lean_interact.config.LeanREPLConfig.project) attribute, the Lean version is automatically inferred from the project. Both [`lean_version`](../api/config.md#lean_interact.config.LeanREPLConfig.lean_version) and [`project`](../api/config.md#lean_interact.config.LeanREPLConfig.project) parameters cannot be specified simultaneously.
 
 ### Local Lean Projects
 
-To work with a local Lean project, create a `LocalProject` instance:
+To work with a local Lean project, create a [`LocalProject`](../api/project.md#lean_interact.project.LocalProject) instance:
 
 ```python
 from lean_interact import LeanREPLConfig, LocalProject, LeanServer
 
 # Configure with a local project
 project = LocalProject(
-    directory="path/to/your/project",
+    directory="path/to/project",
     auto_build=True  # Automatically build the project (default is True)
 )
 config = LeanREPLConfig(project=project)
@@ -39,11 +39,11 @@ server = LeanServer(config)
     Ensure the project can be successfully built with `lake build` before using it with LeanInteract.
 
 !!! tip
-    Setting `auto_build=False` will skip building the project, which can be useful if you've already built it.
+    Setting [`auto_build`](../api/project.md#lean_interact.project.LocalProject.auto_build) to `False` will skip building the project, which can be useful if the project has already been built.
 
 ### Git-Based Projects
 
-You can work with projects hosted on Git repositories:
+Work with projects hosted on Git repositories:
 
 ```python
 from lean_interact import LeanREPLConfig, GitProject, LeanServer
@@ -53,24 +53,24 @@ 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 and the branch has been updated.
+    force_pull=False  # Optional: force update from remote. Useful when the project is already cloned and the branch has been updated.
 )
 config = LeanREPLConfig(project=project)
 server = LeanServer(config)
 ```
 
-The `GitProject` will automatically:
+The [`GitProject`](../api/project.md#lean_interact.project.GitProject) will automatically:
 
 - Clone the repository if it doesn't exist (including submodules if present)
 - Update to the specified revision
 - Build the project with `lake build`
 
 !!! tip
-    Use the `directory` parameter to control where projects are cached
+    Use the [`directory`](../api/project.md#lean_interact.project.GitProject.directory) parameter to control where projects are cached
 
 ## Working with Temporary Projects
 
-LeanInteract allows you to create temporary projects with dependencies for quick experimentation and automated reproducible setups.
+LeanInteract allows creating temporary projects with dependencies for quick experimentation and automated reproducible setups.
 
 ### Simple Temporary Projects with Dependencies
 
@@ -102,7 +102,7 @@ config = LeanREPLConfig(project=project)
 
 ### Fine-Grained Temporary Projects
 
-For more control over the temporary project, you can specify the complete lakefile content:
+For more control over the temporary project, specify the complete lakefile content:
 
 ```python
 from lean_interact import LeanREPLConfig, TemporaryProject
@@ -128,12 +128,12 @@ require mathlib from git
 config = LeanREPLConfig(project=project)
 ```
 
-This approach gives you full control over the Lake configuration.
-Alternatively, you can define the lakefile content using the TOML format by setting `lakefile_type="toml"`.
+This approach gives full control over the Lake configuration.
+Alternatively, define the lakefile content using the TOML format by setting `lakefile_type="toml"`.
 
 ## Using Custom REPL Revisions
 
-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:
+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, this can be customized by specifying a different REPL revision or repository:
 
 ```python
 from lean_interact import LeanREPLConfig, LeanServer
@@ -146,37 +146,37 @@ config = LeanREPLConfig(
 server = LeanServer(config)
 ```
 
-When you specify a `repl_rev`, LeanInteract will try to:
+When specifying a [`repl_rev`](../api/config.md#lean_interact.config.LeanREPLConfig.repl_rev), LeanInteract will try to:
 
 1. Find a tagged revision with the format `{repl_rev}_lean-toolchain-{lean_version}`
-2. If such tag doesn't exist, fall back to using the specified `repl_rev` directly
-3. If `lean_version` is not specified, it will use the latest available Lean version compatible with the REPL
+2. If such tag doesn't exist, fall back to using the specified [`repl_rev`](../api/config.md#lean_interact.config.LeanREPLConfig.repl_rev) directly
+3. If [`lean_version`](../api/config.md#lean_interact.config.LeanREPLConfig.lean_version) is not specified, it will use the latest available Lean version compatible with the REPL
 
 This approach allows for better matching between REPL versions and Lean versions, ensuring compatibility.
 
 !!! warning
-    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:
+    Custom/older REPL implementations may have interfaces that are incompatible with LeanInteract's current commands. For compatibility issues, consider using the [`run_dict`](../api/server.md#lean_interact.server.LeanServer.run_dict) method from [`LeanServer`](../api/server.md#lean_interact.server.LeanServer) to communicate directly with the REPL:
 
     ```python
     result = server.run_dict({"cmd": "your_command_here"})
     ```
 
 !!! note
-    The `repl_rev` and `repl_git` parameters are ignored if you specify `local_repl_path`.
+    The [`repl_rev`](../api/config.md#lean_interact.config.LeanREPLConfig.repl_rev) and [`repl_git`](../api/config.md#lean_interact.config.LeanREPLConfig.repl_git) parameters are ignored if [`local_repl_path`](../api/config.md#lean_interact.config.LeanREPLConfig.local_repl_path) is specified.
 
 ### 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:
+When developing the Lean REPL or using a custom version, a local copy can be used 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)
+config = LeanREPLConfig(local_repl_path="path/to/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.
+    When using [`local_repl_path`](../api/config.md#lean_interact.config.LeanREPLConfig.local_repl_path), any specified [`repl_rev`](../api/config.md#lean_interact.config.LeanREPLConfig.repl_rev), and [`repl_git`](../api/config.md#lean_interact.config.LeanREPLConfig.repl_git) parameters are ignored as the local REPL is used directly.
 
 !!! note
-    Make sure you are using a compatible Lean version between your local REPL and the project you will interact with.
+    Ensure a compatible Lean version is used between the local REPL and the project.

{lean_interact-0.10.4 → lean_interact-0.11.0}/docs/user-guide/data-extraction.md

@@ -4,8 +4,7 @@ LeanInteract makes it easy to extract rich data from elaboration, including decl
 
 ## Declarations
 
-Set `declarations=True` to retrieve a list of `DeclarationInfo` for each declaration introduced in your Lean code.
-Full details about the fields in `DeclarationInfo` can be found in the [API reference](../api/interface.md#lean_interact.interface.DeclarationInfo).
+Set [`declarations`](../api/interface.md#lean_interact.interface.Command.declarations) to `True` to retrieve a list of [`DeclarationInfo`](../api/interface.md#lean_interact.interface.DeclarationInfo) for each declaration introduced in the Lean code.
 
 ```python exec="on" source="above" session="extraction" result="python"
 from lean_interact import LeanServer, LeanREPLConfig, Command
@@ -38,7 +37,7 @@ Tip: See [`examples/extract_mathlib_decls.py`](https://github.com/augustepoiroux
 
 ## Tactics
 
-Use `all_tactics=True` to collect tactic applications with their goals and used constants.
+Use [`all_tactics`](../api/interface.md#lean_interact.interface.Command.all_tactics) to collect tactic applications with their goals and used constants.
 
 ```python exec="on" source="above" session="extraction" result="python"
 resp = server.run(Command(cmd=code, all_tactics=True))
@@ -48,7 +47,7 @@ for t in resp.tactics:
 
 ## InfoTrees
 
-Request `infotree` to obtain structured elaboration information. Accepted values include `"full"`, `"tactics"`, `"original"`, and `"substantive"`. See [InfoTreeOptions](../api/interface.md#lean_interact.interface.InfoTreeOptions) for details.
+Request [`infotree`](../api/interface.md#lean_interact.interface.Command.infotree) to obtain structured elaboration information. Accepted values include `"full"`, `"tactics"`, `"original"`, and `"substantive"`. See [`InfoTreeOptions`](../api/interface.md#lean_interact.interface.InfoTreeOptions) for details.
 
 ```python exec="on" source="above" session="extraction" result="python"
 from lean_interact.interface import InfoTree, InfoTreeOptions
@@ -64,7 +63,7 @@ for tree in trees:
 
 ## Root goals and messages
 
-You can also ask for `root_goals=True` to retrieve initial goals for declarations (even if already proved).
+Set `root_goals=True` to retrieve initial goals for declarations (even if already proved).
 
 ```python exec="on" source="above" session="extraction" result="python"
 print(server.run(Command(cmd=code, root_goals=True)))

{lean_interact-0.10.4 → lean_interact-0.11.0}/docs/user-guide/examples.md

@@ -1,6 +1,6 @@
 # Examples
 
-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.
+This page provides practical examples of using LeanInteract in different scenarios. Full example scripts are available in the [`examples`](https://github.com/augustepoiroux/LeanInteract/tree/main/examples) directory of the repository.
 
 ## Basic Theorem Proving
 
@@ -63,8 +63,8 @@ server = LeanServer(config)
 response = server.run(Command(cmd="#eval Lean.versionString"))
 print(response.messages[0].data)  # Output: "4.21.0-rc3"
 
-# If you encounter interface compatibility issues with custom REPLs,
-# you can use run_dict to communicate directly with the REPL:
+# For interface compatibility issues with custom REPLs,
+# use run_dict to communicate directly with the REPL:
 result = server.run_dict({"cmd": "#eval Lean.versionString"})
 print(result)  # Example raw output from the REPL
 ```
@@ -84,3 +84,6 @@ For more comprehensive examples, check out the following scripts in the examples
 
 4. [**type_check.py**](https://github.com/augustepoiroux/LeanInteract/blob/main/examples/type_check.py)  
    Shows how to optimize type checking using environment states.
+
+5. [**extract_mathlib_decls.py**](https://github.com/augustepoiroux/LeanInteract/blob/main/examples/extract_mathlib_decls.py)  
+   Demonstrates how to extract declarations from Mathlib in parallel using [`LeanServerPool`](../api/pool.md#lean_interact.pool.LeanServerPool).

{lean_interact-0.10.4 → lean_interact-0.11.0}/docs/user-guide/getting-started.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-LeanInteract provides a Python interface to the Lean 4 theorem prover via the Lean REPL (Read-Evaluate-Print Loop). It enables you to:
+LeanInteract provides a Python interface to the Lean 4 theorem prover via the Lean REPL (Read-Evaluate-Print Loop). It enables:
 
 - Execute Lean code from Python
 - Process Lean files
@@ -37,7 +37,7 @@ This will:
 
 ### LeanREPLConfig
 
-`LeanREPLConfig` sets up the Lean environment:
+[`LeanREPLConfig`](../api/config.md#lean_interact.config.LeanREPLConfig) sets up the Lean environment:
 
 ```python
 config = LeanREPLConfig(
@@ -48,13 +48,13 @@ config = LeanREPLConfig(
 
 ### LeanServer
 
-`LeanServer` manages communication with the Lean REPL:
+[`LeanServer`](../api/server.md#lean_interact.server.LeanServer) manages communication with the Lean REPL:
 
 ```python
 server = LeanServer(config)
 ```
 
-A more robust alternative is `AutoLeanServer`, which automatically recovers from (some) crashes:
+A more robust alternative is [`AutoLeanServer`](../api/server.md#lean_interact.server.AutoLeanServer), which automatically recovers from (some) crashes:
 
 ```python
 from lean_interact import AutoLeanServer
@@ -65,9 +65,9 @@ auto_server = AutoLeanServer(config)
 
 LeanInteract provides several types of commands:
 
-- `Command`: Execute Lean code directly
-- `FileCommand`: Process Lean files
-- `ProofStep`: Work with proofs step by step using tactics
+- [`Command`](../api/interface.md#lean_interact.interface.Command): Execute Lean code directly
+- [`FileCommand`](../api/interface.md#lean_interact.interface.FileCommand): Process Lean files
+- [`ProofStep`](../api/interface.md#lean_interact.interface.ProofStep): Work with proofs step by step using tactics
 
 Basic command execution:
 
@@ -78,7 +78,7 @@ server.run(Command(cmd="theorem ex (n : Nat) : n = 5 → n = 5 := id"))
 ## Next Steps
 
 - Learn about [basic usage patterns](basic-usage.md)
-- Explore [tactic mode](tactic-mode.md) for step-by-step proof interaction
+- Explore [performance optimizations](performance.md)
 - Configure [custom Lean environments](custom-lean-configuration.md)
 
 Or check out the [API Reference](../api/config.md) for detailed information on all available classes and methods.

{lean_interact-0.10.4 → lean_interact-0.11.0}/docs/user-guide/installation.md

@@ -2,11 +2,11 @@
 
 ## Prerequisites
 
-Before installing LeanInteract, ensure you have the following prerequisites:
+Before installing LeanInteract, ensure the following prerequisites are met:
 
 - Python 3.10 or newer
 - Git (for Lean installation)
-- [Lean 4](https://leanprover-community.github.io/get_started.html) (optional - LeanInteract can install it for you)
+- [Lean 4](https://leanprover-community.github.io/get_started.html) (optional - LeanInteract can install it)
 
 We recommend using Linux or macOS for the best experience, but LeanInteract also supports Windows.
 
@@ -14,7 +14,7 @@ We recommend using Linux or macOS for the best experience, but LeanInteract also
 
 ### 1. Install the Package
 
-You can install LeanInteract directly from PyPI:
+Install LeanInteract directly from PyPI:
 
 ```bash
 pip install lean-interact
@@ -31,11 +31,11 @@ install-lean
 This command will install Elan, which manages Lean versions.
 
 !!! warning "Elan Version"
-    Your Elan version should be at least 4.0.0.
+    The Elan version should be at least 4.0.0.
 
 ## Verifying Installation
 
-You can verify that LeanInteract is properly installed by running a simple Python script:
+Verify that LeanInteract is properly installed by running a simple Python script:
 
 ```python exec="on" source="above" session="install" result="python"
 from lean_interact import LeanREPLConfig, LeanServer, Command
@@ -54,13 +54,13 @@ 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 the requested Lean version and builds Lean REPL. Subsequent runs will be significantly faster due to caching.
+    The first time LeanInteract is run, 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
 
 ### Windows
 
-On Windows, you might encounter path length limitations. If you get an error related to path length, you can enable long paths in Windows 10 and later versions by running the following command in an administrator PowerShell:
+On Windows, path length limitations may be encountered. For errors related to path length, enable long paths in Windows 10 and later versions by running the following command in an administrator PowerShell:
 
 ```powershell
 New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" -Name LongPathsEnabled -Value 1 -PropertyType DWord -Force
@@ -71,11 +71,11 @@ For more information, refer to the [Microsoft documentation](https://learn.micro
 
 ### Docker
 
-If you're using LeanInteract in a Docker container, make sure to include Git in your container and have sufficient memory allocated, especially if you're working with Mathlib.
+When using LeanInteract in a Docker container, ensure Git is included in the container with sufficient memory allocated, especially when working with Mathlib.
 
 ## Uninstallation
 
-If you need to clear the LeanInteract cache (for troubleshooting or disk space reasons), you can use:
+To clear the LeanInteract cache (for troubleshooting or disk space reasons), use:
 
 ```bash
 clear-lean-cache