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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-interact
-Version: 0.10.0
+Version: 0.10.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.8.0-rc1` and `v4.25.1`.
+- **🔧 Compatibility**: Supports all Lean versions between `v4.8.0-rc1` and `v4.26.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.10.0 → lean_interact-0.10.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.8.0-rc1` and `v4.25.1`.
+- **🔧 Compatibility**: Supports all Lean versions between `v4.8.0-rc1` and `v4.26.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.10.0 → lean_interact-0.10.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.8.0-rc1` and `v4.25.1`
+- **🔧 Compatibility**: Supports all Lean versions between `v4.8.0-rc1` and `v4.26.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.10.0 → lean_interact-0.10.2}/examples/beq_plus.py

@@ -72,7 +72,6 @@ def extract_exact_proof(lean_output: CommandResponse, proof_start_line: int | No
 def check_proof_sub(
     server: AutoLeanServer,
     formal_code: str,
-    context_env: int,
     formal_2_start_line: int,
     proof: str,
     timeout: int,
@@ -98,7 +97,6 @@ def check_proof_sub(
         lean_output = server.run(
             Command(
                 cmd=formal_code + indent_code(prepended + proof, indent_level),
-                env=context_env,
             ),
             timeout=timeout,
         )
@@ -124,7 +122,7 @@ def beql(
     formalization_1: str,
     formalization_2: str,
     src_header: str,
-    repl_config: LeanREPLConfig,
+    server: AutoLeanServer,
     timeout_per_proof: int,
     verbose: bool = False,
 ) -> bool:
@@ -141,11 +139,6 @@ def beql(
     Returns:
         True if both directions of the equivalence hold; False otherwise.
     """
-    server = AutoLeanServer(config=repl_config)
-    context_run = server.run(Command(cmd=src_header), add_to_session_cache=True)
-    assert isinstance(context_run, CommandResponse)
-    context_env = context_run.env
-
     base_thm_name = "base_theorem"
     reformulated_thm_name = "reformulated_theorem"
 
@@ -156,7 +149,9 @@ def beql(
         if verbose:
             console.print(f"=====\nChecking {'1 -> 2' if i == 0 else '2 -> 1'}")
         try:
-            formal_1_code = clean_last_theorem_string(base_thm, base_thm_name, add_sorry=True) + "\n\n"
+            formal_1_code = (
+                src_header + "\n\n" + clean_last_theorem_string(base_thm, base_thm_name, add_sorry=True) + "\n\n"
+            )
             formal_2_start_line = formal_1_code.count("\n") + 1
             formal_2_code = f"{clean_last_theorem_string(reform_thm, reformulated_thm_name, add_sorry=False)} := by"
         except ValueError:
@@ -166,14 +161,12 @@ def beql(
 
         formal_code = formal_1_code + formal_2_code
         # Preliminary check to ensure the formalization is well-typed.
-        if check_proof_sub(server, formal_code, context_env, formal_2_start_line, "sorry", timeout_per_proof) is None:
+        if check_proof_sub(server, formal_code, formal_2_start_line, "sorry", timeout_per_proof) is None:
             if verbose:
                 console.print("Ill-typed formalization encountered, skipping this pair.")
             break
 
-        proof_exact = check_proof_sub(
-            server, formal_code, context_env, formal_2_start_line, "exact?", timeout_per_proof
-        )
+        proof_exact = check_proof_sub(server, formal_code, formal_2_start_line, "exact?", timeout_per_proof)
         if proof_exact and base_thm_name in proof_exact:
             res[i] = True
             if verbose:
@@ -189,7 +182,7 @@ def beq_plus(
     formalization_1: str,
     formalization_2: str,
     src_header: str,
-    repl_config: LeanREPLConfig,
+    server: AutoLeanServer,
     timeout_per_proof: int,
     verbose: bool = False,
 ) -> bool:
@@ -206,11 +199,6 @@ def beq_plus(
     Returns:
         True if both directions of the equivalence hold; False otherwise.
     """
-    server = AutoLeanServer(config=repl_config)
-    context_run = server.run(Command(cmd=src_header), add_to_session_cache=True)
-    assert isinstance(context_run, CommandResponse)
-    context_env = context_run.env
-
     base_thm_name = "base_theorem"
     reformulated_thm_name = "reformulated_theorem"
 
@@ -231,7 +219,9 @@ def beq_plus(
         if verbose:
             console.print(f"=====\nChecking {'1 -> 2' if i == 0 else '2 -> 1'}")
         try:
-            formal_1_code = clean_last_theorem_string(base_thm, base_thm_name, add_sorry=True) + "\n\n"
+            formal_1_code = (
+                src_header + "\n\n" + clean_last_theorem_string(base_thm, base_thm_name, add_sorry=True) + "\n\n"
+            )
             formal_2_start_line = formal_1_code.count("\n") + 1
             formal_2_code = f"{clean_last_theorem_string(reform_thm, reformulated_thm_name, add_sorry=False)} := by"
         except ValueError:
@@ -240,15 +230,13 @@ def beq_plus(
             break
 
         formal_code = formal_1_code + formal_2_code
-        if check_proof_sub(server, formal_code, context_env, formal_2_start_line, "sorry", timeout_per_proof) is None:
+        if check_proof_sub(server, formal_code, formal_2_start_line, "sorry", timeout_per_proof) is None:
             if verbose:
                 console.print("Ill-typed formalization encountered, skipping this pair.")
             break
 
         # 1. Use BEqL
-        proof_exact = check_proof_sub(
-            server, formal_code, context_env, formal_2_start_line, "exact?", timeout_per_proof
-        )
+        proof_exact = check_proof_sub(server, formal_code, formal_2_start_line, "exact?", timeout_per_proof)
         if proof_exact and base_thm_name in proof_exact:
             res[i] = True
             if verbose:
@@ -257,7 +245,7 @@ def beq_plus(
             continue
 
         # If trivially provable by assumption, we skip
-        if check_proof_sub(server, formal_code, context_env, formal_2_start_line, "assumption", timeout_per_proof):
+        if check_proof_sub(server, formal_code, formal_2_start_line, "assumption", timeout_per_proof):
             if verbose:
                 console.print("Skipping as provable by assumption")
             continue
@@ -266,7 +254,6 @@ def beq_plus(
         proof_apply = check_proof_sub(
             server,
             formal_code,
-            context_env,
             formal_2_start_line,
             f"apply {base_thm_name}\n" + proof_all_apply,
             timeout_per_proof,
@@ -284,9 +271,7 @@ def beq_plus(
         # drawback of `have` strategy: variable names/types must match exactly
         provable_without_have = False
         try:
-            res_without_have = server.run(
-                Command(cmd=formal_code + proof_all_have, env=context_env), timeout=timeout_per_proof
-            )
+            res_without_have = server.run(Command(cmd=formal_2_code + proof_all_have), timeout=timeout_per_proof)
             if isinstance(res_without_have, CommandResponse):
                 provable_without_have = res_without_have.lean_code_is_valid(allow_sorry=False)
         except TimeoutError:
@@ -307,7 +292,6 @@ def beq_plus(
                 proof_have = check_proof_sub(
                     server,
                     formal_code,
-                    context_env,
                     formal_2_start_line,
                     have_stmt_proof + proof_all_have,
                     timeout_per_proof,
@@ -324,7 +308,6 @@ def beq_plus(
             proof_convert = check_proof_sub(
                 server,
                 formal_code,
-                context_env,
                 formal_2_start_line,
                 f"convert (config := .unfoldSameFun) {base_thm_name} using {max_step}\n" + proof_all_apply,
                 timeout_per_proof,
@@ -344,6 +327,7 @@ def beq_plus(
 
 def examples_limitations(metric):
     repl_config = LeanREPLConfig(project=TempRequireProject(lean_version="v4.8.0", require="mathlib"), verbose=True)
+    server = AutoLeanServer(config=repl_config)
 
     src_header = """import Mathlib
 
@@ -414,7 +398,7 @@ open scoped BigOperators"""
             formalization_1,
             formalization_2,
             src_header,
-            repl_config,
+            server,
             timeout_per_proof=DEFAULT_TIMEOUT,
             verbose=True,
         )
@@ -429,6 +413,7 @@ open scoped BigOperators"""
 
 def proofnetverif(metric, n_samples=100):
     repl_config = LeanREPLConfig(project=TempRequireProject(lean_version="v4.8.0", require="mathlib"), verbose=True)
+    server = AutoLeanServer(config=repl_config)
 
     dataset = load_dataset("PAug/ProofNetVerif", split="valid")
     dataset = dataset.shuffle(seed=42).select(range(n_samples))
@@ -440,7 +425,7 @@ def proofnetverif(metric, n_samples=100):
                 example["lean4_formalization"],
                 example["lean4_prediction"],
                 example["lean4_src_header"],
-                repl_config,
+                server,
                 timeout_per_proof=DEFAULT_TIMEOUT,
                 verbose=False,
             )

{lean_interact-0.10.0 → lean_interact-0.10.2}/examples/extract_mathlib_decls.py

@@ -1,3 +1,10 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "lean-interact",
+#     "tqdm",
+# ]
+# ///
 """Clone mathlib4 and extract all Lean declarations in parallel (per-file tasks).
 
 Output: mathlib_declarations.jsonl (JSONL, one declaration per line).

lean_interact-0.10.2/examples/type_check.py

@@ -0,0 +1,69 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "datasets",
+#     "lean-interact",
+#     "rich",
+#     "tqdm",
+# ]
+# ///
+"""
+This module shows how to type-check / compile Lean4 snippets, leveraging automatic incremental state reuse.
+"""
+
+import json
+from typing import Any
+
+from datasets import load_dataset
+from rich.console import Console
+from tqdm import tqdm
+
+from lean_interact import AutoLeanServer, LeanREPLConfig
+from lean_interact.interface import Command, CommandResponse
+from lean_interact.project import TempRequireProject
+
+console = Console()
+DEFAULT_TIMEOUT = 60
+
+
+def type_check_sequential(dataset: list[dict[str, Any]], repl_config: LeanREPLConfig) -> list[bool]:
+    """
+    Type-checks each formalization sequentially.
+
+    Args:
+        dataset: A list of dictionaries with keys 'lean4_src_header' and 'lean4_formalization'.
+        repl_config: Configuration for the Lean REPL.
+
+    Returns:
+        A list of booleans indicating if each formalization is valid.
+    """
+    server = AutoLeanServer(repl_config)
+    successes = [False for _ in dataset]
+    for idx, row in enumerate(tqdm(dataset)):
+        src_header = row["lean4_src_header"]
+        formalization = row["lean4_formalization"]
+        try:
+            server_output = server.run(
+                Command(cmd=src_header + "\n" + formalization + " sorry"), timeout=DEFAULT_TIMEOUT
+            )
+            if isinstance(server_output, CommandResponse):
+                successes[idx] = server_output.lean_code_is_valid()
+        except (TimeoutError, ConnectionAbortedError, json.JSONDecodeError) as e:
+            console.log(f"Error while type checking entry {idx}: {e}")
+    return successes
+
+
+if __name__ == "__main__":
+    proofnetsharp = load_dataset("PAug/ProofNetSharp", split="valid")
+    config = LeanREPLConfig(project=TempRequireProject(lean_version="v4.16.0-rc2", require="mathlib"), verbose=True)
+
+    type_check_results = type_check_sequential(proofnetsharp, config)
+    assert len(type_check_results) == len(proofnetsharp)
+
+    if any(not well_typed for well_typed in type_check_results):
+        console.log("Failures:")
+        for i, well_typed in enumerate(type_check_results):
+            if not well_typed:
+                console.log(proofnetsharp[i])
+    else:
+        console.log("All formalizations are well-typed!")

{lean_interact-0.10.0 → lean_interact-0.10.2}/mkdocs.yml

@@ -134,7 +134,7 @@ nav:
       - Getting Started: user-guide/getting-started.md
       - Basic Usage: user-guide/basic-usage.md
       - Tactic Mode: user-guide/tactic-mode.md
-      - Performance & Multi-processing: user-guide/performance.md
+      - Performance & Parallelization: user-guide/performance.md
       - Data Extraction: user-guide/data-extraction.md
       - Set Lean Options: user-guide/set-options.md
       - Examples: user-guide/examples.md

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

@@ -1,6 +1,6 @@
 [project]
 name = "lean-interact"
-version = "0.10.0"
+version = "0.10.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.10.0 → lean_interact-0.10.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.3.8"
+DEFAULT_REPL_VERSION = "v1.3.10"
 
 os.makedirs(DEFAULT_CACHE_DIR, exist_ok=True)
 

{lean_interact-0.10.0 → lean_interact-0.10.2}/tests/test_server.py

@@ -71,8 +71,7 @@ class TestLeanServer(unittest.TestCase):
         LeanREPLConfig(project=TempRequireProject(lean_version=cls.mostRecentVersion, require="mathlib"), verbose=True)
 
     def test_init_with_lean_version(self):
-        for version in [self.oldestVersion, "v4.14.0"]:
-            # for version in [self.oldestVersion, "v4.14.0", self.mostRecentVersion]: # temporarily skip most recent because v4.25.1 wrongly returns v4.25.0
+        for version in [self.oldestVersion, "v4.14.0", self.mostRecentVersion]:
             server = AutoLeanServer(config=LeanREPLConfig(lean_version=version, verbose=True))
             self.assertEqual(server.lean_version, version)
             self.assertEqual(
@@ -144,29 +143,6 @@ class TestLeanServer(unittest.TestCase):
             response = server.run(Command(cmd="#eval Lean.versionString"), verbose=True)
             self.assertIsInstance(response, CommandResponse)
 
-    def test_init_with_official_repl(self):
-        config = LeanREPLConfig(
-            repl_rev="v4.25.0-rc2", repl_git="https://github.com/leanprover-community/repl", verbose=True
-        )
-        server = AutoLeanServer(config=config)
-        self.assertEqual(server.lean_version, "v4.25.0-rc2")
-        response = server.run(Command(cmd="#eval Lean.versionString"), verbose=True)
-        self.assertIsInstance(response, CommandResponse)
-        self.assertEqual(
-            response,
-            CommandResponse(
-                messages=[
-                    Message(
-                        start_pos=Pos(line=1, column=0),
-                        end_pos=Pos(line=1, column=5),
-                        severity="info",
-                        data='"4.25.0-rc2"',
-                    )
-                ],
-                env=0,
-            ),
-        )
-
     def test_temp_project_creation(self):
         # Create a simple temporary project
         temp_content = """

lean_interact-0.10.0/examples/type_check.py

@@ -1,118 +0,0 @@
-# /// script
-# requires-python = ">=3.10"
-# dependencies = [
-#     "datasets",
-#     "lean-interact",
-#     "rich",
-#     "tqdm",
-# ]
-# ///
-"""
-This module provides functions to type-check Lean formalizations
-using sequential and optimized batch methods.
-"""
-
-import json
-from typing import Any
-
-from datasets import load_dataset
-from rich.console import Console
-from tqdm import tqdm
-
-from lean_interact import AutoLeanServer, LeanREPLConfig
-from lean_interact.interface import Command, CommandResponse
-from lean_interact.project import TempRequireProject
-
-console = Console()
-DEFAULT_TIMEOUT = 60
-
-
-def type_check_sequential(dataset: list[dict[str, Any]], repl_config: LeanREPLConfig) -> list[bool]:
-    """
-    Type-checks each formalization sequentially.
-
-    Args:
-        dataset: A list of dictionaries with keys 'lean4_src_header' and 'lean4_formalization'.
-        repl_config: Configuration for the Lean REPL.
-
-    Returns:
-        A list of booleans indicating if each formalization is valid.
-    """
-    server = AutoLeanServer(repl_config)
-    successes = [False for _ in dataset]
-    for idx, row in enumerate(tqdm(dataset)):
-        src_header = row["lean4_src_header"]
-        formalization = row["lean4_formalization"]
-        try:
-            server_output = server.run(
-                Command(cmd=src_header + "\n" + formalization + " sorry"), timeout=DEFAULT_TIMEOUT
-            )
-            if isinstance(server_output, CommandResponse):
-                successes[idx] = server_output.lean_code_is_valid()
-        except (TimeoutError, ConnectionAbortedError, json.JSONDecodeError) as e:
-            console.log(f"Error while type checking entry {idx}: {e}")
-    return successes
-
-
-def type_check_sequential_optimized(dataset: list[dict[str, Any]], repl_config: LeanREPLConfig) -> list[bool]:
-    """
-    Optimized type-checking by batching formalizations with a common context.
-
-    Args:
-        dataset: A list of dictionaries with keys 'lean4_src_header' and 'lean4_formalization'.
-        repl_config: Configuration for the Lean REPL.
-
-    Returns:
-        A list of booleans indicating if each formalization is valid.
-    """
-    # Group by common src header
-    formalizations_idx = list(enumerate(dataset))
-    formalizations_grouped: dict[str, list] = {}
-    for idx, row in formalizations_idx:
-        header = row["lean4_src_header"]
-        formalizations_grouped.setdefault(header, []).append((idx, row["lean4_formalization"]))
-
-    def type_check_group(src_header: str, group: list) -> list[int]:
-        server = AutoLeanServer(repl_config)
-        context_res = server.run(Command(cmd=src_header), add_to_session_cache=True)
-        if not isinstance(context_res, CommandResponse):
-            console.log(f"Error while loading context for header '{src_header}': {context_res}")
-            return []
-        context_env = context_res.env
-        valid_indices = []
-        for idx, formalization in group:
-            try:
-                server_output = server.run(
-                    Command(cmd=formalization + " sorry", env=context_env), timeout=DEFAULT_TIMEOUT
-                )
-                if isinstance(server_output, CommandResponse) and server_output.lean_code_is_valid():
-                    valid_indices.append(idx)
-            except (TimeoutError, ConnectionAbortedError, json.JSONDecodeError) as e:
-                console.log(f"Error in group with header '{src_header}': {e}")
-        return valid_indices
-
-    res: list[bool] = [False for _ in dataset]
-    for idx, group in enumerate(tqdm(formalizations_grouped.items())):
-        src_header, group = group
-        valid_indices = type_check_group(src_header, group)
-        for idx in valid_indices:
-            res[idx] = True
-    return res
-
-
-if __name__ == "__main__":
-    proofnetsharp = load_dataset("PAug/ProofNetSharp", split="valid")
-    config = LeanREPLConfig(project=TempRequireProject(lean_version="v4.16.0-rc2", require="mathlib"), verbose=True)
-
-    # type_check_results = type_check_sequential(proofnetsharp, config)
-    type_check_results = type_check_sequential_optimized(proofnetsharp, config)
-
-    assert len(type_check_results) == len(proofnetsharp)
-
-    if any(not well_typed for well_typed in type_check_results):
-        console.log("Failures:")
-        for i, well_typed in enumerate(type_check_results):
-            if not well_typed:
-                console.log(proofnetsharp[i])
-    else:
-        console.log("All formalizations are well-typed!")