lean-python 0.1.0__tar.gz → 0.2.0__tar.gz

{lean_python-0.1.0 → lean_python-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lean-python
-Version: 0.1.0
+Version: 0.2.0
 Summary: Run Lean 4 code as Python: a runtime for code generated from Lean's IR, Lean blocks in Python files, and pydantic models for Lean types
 Project-URL: Repository, https://github.com/conao3/lean-py
 License-Expression: Apache-2.0
@@ -170,12 +170,94 @@ member), `Literal["a", "b"]` (`LeanPythonLiterals.<module>.<Model>_<field>`), an
 docstring lists them. Generated functions take and return your classes; values that did not go
 through validation (`model_construct`) are checked again on the way to Lean.
 
+## Verifying Python functions
+
+`@model` binds a typed, pure Python function to specifications written in a Lean block. The function
+stays ordinary Python; `lean-py check` translates it to Lean and checks your proofs, and
+`check_model` runs the same specifications as a Hypothesis property test.
+
+```python
+from lean_python import lean
+from lean_python.verify import model
+
+spec = lean("spec", r"""
+def clampSpec (x lo hi : Int) : Int := max lo (min hi x)
+def ordered (_x lo hi : Int) : Bool := lo ≤ hi
+def inRange (_x lo hi : Int) (r : Int) : Bool := lo ≤ r && r ≤ hi
+""")
+
+@model(refines=spec.clampSpec, requires=spec.ordered, ensures={"in_range": spec.inRange})
+def clamp(x: int, lo: int, hi: int) -> int:
+    if x < lo:
+        return lo
+    if x > hi:
+        return hi
+    return x
+```
+
+`lean-py check --package calc` writes the translation and one obligation per specification:
+
+```lean
+def LeanPythonModel.calc.calc.clamp (x : Int) (lo : Int) (hi : Int) : Int := Id.run do
+  if ((decide (x < lo))) then
+    return lo
+  if ((decide (x > hi))) then
+    return hi
+  return x
+
+abbrev LeanPythonModel.calc.calc.clamp.obligation.refines : Prop :=
+  ∀ (x : Int) (lo : Int) (hi : Int), ordered x lo hi = true → clamp x lo hi = clampSpec x lo hi
+```
+
+and judges the theorems `<function>.proof.<label>` of `lean/Proofs/*.lean` next to `pyproject.toml`:
+
+```lean
+import LeanPythonModel.calc.calc
+open LeanPythonEmbed.calc.spec.spec
+namespace LeanPythonModel.«calc».«calc»
+
+theorem clamp.proof.refines : clamp.obligation.refines := by
+  intro x lo hi h
+  simp only [ordered, decide_eq_true_eq] at h
+  simp only [clamp, clampSpec]
+  split <;> (try split) <;> simp_all <;> omega
+```
+
+```
+proved     calc.calc:clamp refines
+proved     calc.calc:clamp in_range
+sorry      calc.calc:sum_to refines
+missing    calc.calc:sum_abs nonneg
+```
+
+A `for` loop over a list becomes `List.foldl` under `simp` (`forIn_pure_yield_eq_foldl`), so a loop
+is proved by induction on the list (`tests/verify/lean/Proofs/Calc.lean` proves `sum_abs`).
+
+The states are proved, sorry, axioms (non-standard axioms), failed (the proof file does not build),
+missing, mismatch (the theorem states something else). `--require proved` fails unless all are
+proved. The result goes to `lean-python.lock` with a hash of each function's source;
+`lean-py status` reads it without Lean and marks changed functions `stale`.
+
+- `refines=s`: `f x = s x` (`Except.ok (s x)` for a function that may fail); `requires=p`: `p x = true →`
+  before each obligation; `ensures={"label": q}`: `q x (f x) = true`. A function annotated `-> Nat`
+  also gets `returns_nat` (`0 ≤ f x`).
+- The translation: `int` is `Int` (a `Nat` parameter is a `Nat` converted to `Int` on entry);
+  statements become Lean `do` notation (`let mut`, `for`, `while`, `break`, `continue`, early
+  `return`); indexing, `//`, `%`, `assert` and `raise` make the function return
+  `Py.M α = Except Py.Exc α`, with Python's negative indices and floor division (`LeanPythonLib.Py`).
+  Supported: `int`, `bool`, `str`, `float`, `list`, `tuple`, `T | None`, pydantic models (as the
+  Lean structures of `models=`), `len`, `abs`, `min`, `max`, `sum`, list comprehensions, `append` on
+  local lists, and calls of other `@model` functions of the module.
+- `check_model(f)` / `check_module(m)` generate arguments from the annotations (pydantic constraints
+  included), skip those failing `requires`, and compare with `refines` and `ensures`.
+
 ## The CLI
 
 ```
 lean-python module generate --module-name <Name> [--roots <Name> ...] [--namespace <Name>]
   [--search-path <dir> ...] [--output-file <path>] [--internal-only] [--output json|text]
   [--type-module <Name>=<module> ...] [--model-module <Name>=<module> ...] [--batch <file>]
+lean-python obligations check --modules <Name> ... --obligations <file> [--search-path <dir> ...]
 lean-python --version | --generator-version | help
 ```
 
@@ -224,7 +306,7 @@ nix develop -c make bench
 - `Task`s run synchronously.
 - Building a `String` with `String.push` copies the string each time (Python `bytes`), so it grows
   quadratically.
-- Python's own functions are not verified in Lean yet.
+- The translation of Python functions covers the subset above; the guarantee is partial correctness.
 
 ## License
 

{lean_python-0.1.0 → lean_python-0.2.0}/README.md

@@ -156,12 +156,94 @@ member), `Literal["a", "b"]` (`LeanPythonLiterals.<module>.<Model>_<field>`), an
 docstring lists them. Generated functions take and return your classes; values that did not go
 through validation (`model_construct`) are checked again on the way to Lean.
 
+## Verifying Python functions
+
+`@model` binds a typed, pure Python function to specifications written in a Lean block. The function
+stays ordinary Python; `lean-py check` translates it to Lean and checks your proofs, and
+`check_model` runs the same specifications as a Hypothesis property test.
+
+```python
+from lean_python import lean
+from lean_python.verify import model
+
+spec = lean("spec", r"""
+def clampSpec (x lo hi : Int) : Int := max lo (min hi x)
+def ordered (_x lo hi : Int) : Bool := lo ≤ hi
+def inRange (_x lo hi : Int) (r : Int) : Bool := lo ≤ r && r ≤ hi
+""")
+
+@model(refines=spec.clampSpec, requires=spec.ordered, ensures={"in_range": spec.inRange})
+def clamp(x: int, lo: int, hi: int) -> int:
+    if x < lo:
+        return lo
+    if x > hi:
+        return hi
+    return x
+```
+
+`lean-py check --package calc` writes the translation and one obligation per specification:
+
+```lean
+def LeanPythonModel.calc.calc.clamp (x : Int) (lo : Int) (hi : Int) : Int := Id.run do
+  if ((decide (x < lo))) then
+    return lo
+  if ((decide (x > hi))) then
+    return hi
+  return x
+
+abbrev LeanPythonModel.calc.calc.clamp.obligation.refines : Prop :=
+  ∀ (x : Int) (lo : Int) (hi : Int), ordered x lo hi = true → clamp x lo hi = clampSpec x lo hi
+```
+
+and judges the theorems `<function>.proof.<label>` of `lean/Proofs/*.lean` next to `pyproject.toml`:
+
+```lean
+import LeanPythonModel.calc.calc
+open LeanPythonEmbed.calc.spec.spec
+namespace LeanPythonModel.«calc».«calc»
+
+theorem clamp.proof.refines : clamp.obligation.refines := by
+  intro x lo hi h
+  simp only [ordered, decide_eq_true_eq] at h
+  simp only [clamp, clampSpec]
+  split <;> (try split) <;> simp_all <;> omega
+```
+
+```
+proved     calc.calc:clamp refines
+proved     calc.calc:clamp in_range
+sorry      calc.calc:sum_to refines
+missing    calc.calc:sum_abs nonneg
+```
+
+A `for` loop over a list becomes `List.foldl` under `simp` (`forIn_pure_yield_eq_foldl`), so a loop
+is proved by induction on the list (`tests/verify/lean/Proofs/Calc.lean` proves `sum_abs`).
+
+The states are proved, sorry, axioms (non-standard axioms), failed (the proof file does not build),
+missing, mismatch (the theorem states something else). `--require proved` fails unless all are
+proved. The result goes to `lean-python.lock` with a hash of each function's source;
+`lean-py status` reads it without Lean and marks changed functions `stale`.
+
+- `refines=s`: `f x = s x` (`Except.ok (s x)` for a function that may fail); `requires=p`: `p x = true →`
+  before each obligation; `ensures={"label": q}`: `q x (f x) = true`. A function annotated `-> Nat`
+  also gets `returns_nat` (`0 ≤ f x`).
+- The translation: `int` is `Int` (a `Nat` parameter is a `Nat` converted to `Int` on entry);
+  statements become Lean `do` notation (`let mut`, `for`, `while`, `break`, `continue`, early
+  `return`); indexing, `//`, `%`, `assert` and `raise` make the function return
+  `Py.M α = Except Py.Exc α`, with Python's negative indices and floor division (`LeanPythonLib.Py`).
+  Supported: `int`, `bool`, `str`, `float`, `list`, `tuple`, `T | None`, pydantic models (as the
+  Lean structures of `models=`), `len`, `abs`, `min`, `max`, `sum`, list comprehensions, `append` on
+  local lists, and calls of other `@model` functions of the module.
+- `check_model(f)` / `check_module(m)` generate arguments from the annotations (pydantic constraints
+  included), skip those failing `requires`, and compare with `refines` and `ensures`.
+
 ## The CLI
 
 ```
 lean-python module generate --module-name <Name> [--roots <Name> ...] [--namespace <Name>]
   [--search-path <dir> ...] [--output-file <path>] [--internal-only] [--output json|text]
   [--type-module <Name>=<module> ...] [--model-module <Name>=<module> ...] [--batch <file>]
+lean-python obligations check --modules <Name> ... --obligations <file> [--search-path <dir> ...]
 lean-python --version | --generator-version | help
 ```
 
@@ -210,7 +292,7 @@ nix develop -c make bench
 - `Task`s run synchronously.
 - Building a `String` with `String.push` copies the string each time (Python `bytes`), so it grows
   quadratically.
-- Python's own functions are not verified in Lean yet.
+- The translation of Python functions covers the subset above; the guarantee is partial correctness.
 
 ## License
 

{lean_python-0.1.0 → lean_python-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lean-python"
-version = "0.1.0"
+version = "0.2.0"
 description = "Run Lean 4 code as Python: a runtime for code generated from Lean's IR, Lean blocks in Python files, and pydantic models for Lean types"
 readme = "README.md"
 license = "Apache-2.0"

lean_python-0.2.0/src/lean_python/check.py

@@ -0,0 +1,292 @@
+"""``lean-py check`` and ``lean-py status``: the proofs of the ``@model`` functions of a package.
+
+``check`` syncs the package's Lean blocks, translates every ``@model`` function into
+``LeanPythonModel.<module>`` with one obligation per specification (``<function>.obligation.<label>``),
+builds them with the proofs in ``<project>/lean/Proofs/`` (theorems ``<function>.proof.<label>``),
+and asks the Lean CLI for the state of each obligation: proved, sorry, axioms, missing,
+mismatch. The result and a hash of each function's source go to ``<project>/lean-python.lock``.
+``status`` reads the lock without Lean and marks a function stale when its source changed.
+"""
+
+import ast
+import hashlib
+import importlib
+import inspect
+import json
+import pathlib
+import shutil
+import subprocess
+import sys
+import textwrap
+
+from lean_python import models, sync, translate, verify
+
+LAKEFILE_EXTRA = """
+[[lean_lib]]
+name = "LeanPythonLib"
+
+[[lean_lib]]
+name = "LeanPythonModel"
+
+[[lean_lib]]
+name = "Proofs"
+globs = ["Proofs.+"]
+"""
+
+STATUSES = ("proved", "sorry", "axioms", "failed", "missing", "mismatch", "unextracted", "stale")
+
+
+def model_module(module):
+    return ["LeanPythonModel", *module.split(".")]
+
+
+def function_name(fn):
+    return models.dotted([*model_module(fn.__module__), fn.__qualname__])
+
+
+def source_hash(fn):
+    src = textwrap.dedent(inspect.getsource(fn))
+    return hashlib.sha256(ast.dump(ast.parse(src)).encode()).hexdigest()
+
+
+def lean_name_of(spec_fn, label, fn):
+    name = getattr(spec_fn, "__lean_name__", None)
+    if name is None:
+        raise sync.SyncError(
+            f"{fn.__qualname__}: the {label} specification is not a function of a lean(...) block", 252
+        )
+    return name, getattr(spec_fn, "__lean_module__", None)
+
+
+def obligations(spec, tfn):
+    """The Lean statements of the obligations of one function, by label."""
+    fn = spec.fn
+    binders = []
+    args = []
+    for name, ann in tfn.params:
+        t = translate.py_type(ann, fn)
+        ty = "Nat" if translate.is_nat(ann) else translate.lean_type(t)
+        binders.append(f"({translate.lean_ident(name)} : {ty})")
+        args.append(translate.lean_ident(name))
+    call = f"({tfn.lean_name} {' '.join(args)})"
+    a = " ".join(args)
+    imports = set()
+    pre = ""
+    if spec.requires is not None:
+        r, m = lean_name_of(spec.requires, "requires", fn)
+        imports.add(m)
+        pre = f"{r} {a} = true → "
+    out = {}
+
+    def wrap(body):
+        return f"∀ {' '.join(binders)}, {pre}{body}" if binders else f"{pre}{body}"
+
+    if spec.refines is not None:
+        s, m = lean_name_of(spec.refines, "refines", fn)
+        imports.add(m)
+        ret = getattr(spec.refines, "__annotations__", {}).get("return")
+        expected = f"(({s} {a} : Nat) : Int)" if ret == "Nat" else f"({s} {a})"
+        out["refines"] = wrap(f"{call} = Except.ok {expected}" if tfn.fails else f"{call} = {expected}")
+    for label, e in spec.ensures.items():
+        en, m = lean_name_of(e, label, fn)
+        imports.add(m)
+        out[label] = wrap(f"∀ r, {call} = Except.ok r → {en} {a} r = true" if tfn.fails else f"{en} {a} {call} = true")
+    if tfn.ret_nat:
+        out["returns_nat"] = wrap(f"∀ r, {call} = Except.ok r → 0 ≤ r" if tfn.fails else f"0 ≤ {call}")
+    return out, {i for i in imports if i}
+
+
+def reimport(pkg):
+    for name in [m for m in sys.modules if m == pkg or m.startswith(pkg + ".")]:
+        del sys.modules[name]
+    importlib.invalidate_caches()
+
+
+def check_package(pkg_dir, cli=None, out=sys.stderr):
+    pkg_dir = pathlib.Path(pkg_dir).resolve()
+    cli = cli or shutil.which("lean-python")
+    sync.sync_package(pkg_dir, cli=cli, out=out)
+    root = sync.project_root(pkg_dir)
+    ws = root / ".lean-python" / "workspace"
+
+    reimport(pkg_dir.name)
+    verify.REGISTRY.clear()
+    for path in sorted(pkg_dir.rglob("*.py")):
+        rel = path.relative_to(pkg_dir)
+        if rel.parts[0] == "_lean" or rel.name == "__main__.py":
+            continue
+        parts = [pkg_dir.name, *rel.with_suffix("").parts]
+        if parts[-1] == "__init__":
+            parts = parts[:-1]
+        importlib.import_module(".".join(parts))
+    specs = list(verify.REGISTRY)
+
+    lib = ws / "LeanPythonLib"
+    shutil.rmtree(lib, ignore_errors=True)
+    shutil.copytree(pathlib.Path(__file__).parent / "lean" / "LeanPythonLib", lib)
+    (ws / "LeanPythonLib.lean").write_text("import LeanPythonLib.Py\n")
+    shutil.rmtree(ws / "LeanPythonModel", ignore_errors=True)
+    shutil.rmtree(ws / "Proofs", ignore_errors=True)
+    proofs_src = root / "lean" / "Proofs"
+    if proofs_src.is_dir():
+        shutil.copytree(proofs_src, ws / "Proofs")
+    else:
+        (ws / "Proofs").mkdir()
+    (ws / "Proofs" / "Empty.lean").write_text("")
+    lakefile = (ws / "lakefile.toml").read_text()
+    (ws / "lakefile.toml").write_text(lakefile + LAKEFILE_EXTRA)
+
+    by_module = {}
+    for s in specs:
+        by_module.setdefault(s.fn.__module__, []).append(s)
+    model_modules = []
+    obligation_refs = []
+    for module, ss in by_module.items():
+        tfns = [translate.Fn(s.fn, function_name(s.fn)) for s in ss]
+        tr = translate.Translator(tfns)
+        model_classes = set()
+        for t in tfns:
+            for _, ann in t.params:
+                _collect_models(ann, model_classes)
+            _collect_models(t.hints["return"], model_classes)
+        imports = {"LeanPythonLib.Py"}
+        imports |= (
+            {models.dotted(models.models_namespace(m)) for m in models.modules_source(list(model_classes))}
+            if model_classes
+            else set()
+        )
+        defs = []
+        for s, t in zip(ss, tfns, strict=True):
+            try:
+                defs.append(tr.definition(t))
+            except translate.TranslateError as e:
+                raise sync.SyncError(str(e), 254) from None
+            obls, extra = obligations(s, t)
+            imports |= extra
+            for label, prop in obls.items():
+                defs.append(f"abbrev {t.lean_name}.obligation.{label} : Prop :=\n  {prop}")
+                obligation_refs.append((s, label))
+        missing_models = [m for m in models.modules_source(list(model_classes))] if model_classes else []
+        for m in missing_models:
+            p = ws / pathlib.Path(*models.models_namespace(m)).with_suffix(".lean")
+            if not p.exists():
+                p.parent.mkdir(parents=True, exist_ok=True)
+                p.write_text(models.modules_source(list(model_classes))[m])
+        path = ws / pathlib.Path(*model_module(module)).with_suffix(".lean")
+        path.parent.mkdir(parents=True, exist_ok=True)
+        head = "".join(f"import {i}\n" for i in sorted(imports))
+        path.write_text(head + "\n" + "\n\n".join(defs) + "\n")
+        model_modules.append(".".join(model_module(module)))
+    (ws / "LeanPythonModel.lean").write_text(
+        "".join(f"import {models.dotted(m.split('.'))}\n" for m in model_modules) or "\n"
+    )
+    (ws / "LeanPythonModels.lean").write_text(
+        "".join(
+            f"import {models.dotted(p.relative_to(ws).with_suffix('').parts)}\n"
+            for p in sorted((ws / "LeanPythonModels").rglob("*.lean"))
+        )
+        if (ws / "LeanPythonModels").is_dir()
+        else "\n"
+    )
+    proof_modules = [".".join(p.relative_to(ws).with_suffix("").parts) for p in sorted((ws / "Proofs").rglob("*.lean"))]
+    (ws / "Proofs.lean").write_text("".join(f"import {models.dotted(m.split('.'))}\n" for m in proof_modules))
+
+    r = subprocess.run(
+        ["lake", "build", "LeanPythonLib", "LeanPythonModels", "LeanPythonEmbed", "LeanPythonModel"],
+        cwd=ws,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if r.returncode != 0:
+        print(r.stdout + r.stderr, file=out)
+        raise sync.SyncError("lake build of the translated functions failed", 254)
+    failed_files = {}
+    built = []
+    for m in proof_modules:
+        r = subprocess.run(["lake", "build", m], cwd=ws, capture_output=True, text=True, check=False)
+        if r.returncode == 0:
+            built.append(m)
+            continue
+        src = (ws / pathlib.Path(*m.split("."))).with_suffix(".lean")
+        failed_files[m] = src.read_text()
+        for line in (r.stdout + r.stderr).splitlines():
+            if line.startswith(("error:", "  ", "⊢", "case ")) or ": error" in line:
+                print(f"lean-py: {line}", file=out)
+    proof_modules = built
+
+    obl_file = ws / "obligations.json"
+    obl_file.write_text(
+        json.dumps([{"model": _plain(function_name(s.fn)), "label": label} for s, label in obligation_refs])
+    )
+    r = subprocess.run(
+        [
+            cli,
+            "obligations",
+            "check",
+            "--search-path",
+            str(ws / ".lake/build/lib/lean"),
+            "--obligations",
+            str(obl_file),
+            "--modules",
+            *model_modules,
+            *proof_modules,
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if r.returncode != 0:
+        print(r.stderr, file=out)
+        raise sync.SyncError("lean-python obligations check failed", r.returncode)
+    results = json.loads(r.stdout)
+    for (s, label), res in zip(obligation_refs, results, strict=True):
+        theorem = f"{s.fn.__qualname__}.proof.{label}"
+        if res["status"] == "missing" and any(theorem in text for text in failed_files.values()):
+            res["status"] = "failed"
+    lock = {}
+    for (s, label), res in zip(obligation_refs, results, strict=True):
+        entry = lock.setdefault(s.qualname, {"hash": source_hash(s.fn), "lean": function_name(s.fn), "obligations": {}})
+        entry["obligations"][label] = res["status"]
+    (root / "lean-python.lock").write_text(json.dumps(lock, indent=2, sort_keys=True) + "\n")
+    return lock, results
+
+
+def _plain(name):
+    return name.replace("«", "").replace("»", "")
+
+
+def _collect_models(ann, acc):
+    import typing
+
+    from pydantic import BaseModel
+
+    while typing.get_origin(ann) is typing.Annotated:
+        ann = typing.get_args(ann)[0]
+    if isinstance(ann, type) and issubclass(ann, BaseModel):
+        acc.add(ann)
+        return
+    for a in typing.get_args(ann):
+        _collect_models(a, acc)
+
+
+def status(pkg_dir):
+    """The lock's states, with ``stale`` for functions whose source changed (no Lean needed)."""
+    pkg_dir = pathlib.Path(pkg_dir).resolve()
+    root = sync.project_root(pkg_dir)
+    lock_path = root / "lean-python.lock"
+    lock = json.loads(lock_path.read_text()) if lock_path.exists() else {}
+    sys.path.insert(0, str(pkg_dir.parent))
+    verify.REGISTRY.clear()
+    sync.record_blocks(pkg_dir)
+    rows = []
+    for s in verify.REGISTRY:
+        entry = lock.get(s.qualname)
+        labels = list(s.specs())
+        if entry is None:
+            rows.extend((s.qualname, label, "stale") for label in labels if label != "requires")
+            continue
+        stale = entry["hash"] != source_hash(s.fn)
+        for label, st in entry["obligations"].items():
+            rows.append((s.qualname, label, "stale" if stale else st))
+    return rows

lean_python-0.2.0/src/lean_python/cli.py

@@ -0,0 +1,73 @@
+"""``lean-py``: the command line of the Python package.
+
+usage: lean-py sync --package <dir> [--lean-python <path>]
+"""
+
+import argparse
+import os
+import sys
+
+USAGE = """usage: lean-py <command> [parameters]
+
+commands:
+  sync     Check the Lean blocks of a package and generate their Python modules
+  check    Translate the @model functions to Lean and judge the proofs of their obligations
+  status   Show the states recorded by `check`, marking functions changed since then (no Lean)
+
+lean-py sync
+  --package <dir>        The Python package (the directory with __init__.py) (required)
+  --lean-python <path>   The Lean CLI (default: $LEAN_PYTHON_CLI, then `lean-python` on PATH)
+
+lean-py check
+  --package <dir>, --lean-python <path>   as for sync
+  --require proved       Exit with 254 unless every obligation is proved
+
+lean-py status
+  --package <dir>        The Python package (required)
+
+exit codes: 0 success, 252 invalid parameters, 254 input that cannot be converted, 255 other errors
+"""
+
+
+def main(argv=None):
+    argv = sys.argv[1:] if argv is None else argv
+    if not argv or argv[0] in ("help", "--help", "-h"):
+        print(USAGE, end="")
+        return 0
+    command = argv[0]
+    if command not in ("sync", "check", "status"):
+        print(f"lean-py: unknown command {command!r} (see `lean-py help`)", file=sys.stderr)
+        return 252
+    p = argparse.ArgumentParser(prog=f"lean-py {command}", add_help=False, exit_on_error=False)
+    p.add_argument("--package", required=True)
+    p.add_argument("--lean-python")
+    p.add_argument("--require", choices=["proved"])
+    try:
+        args = p.parse_args(argv[1:])
+    except (argparse.ArgumentError, SystemExit) as e:
+        print(f"lean-py: {e}", file=sys.stderr)
+        return 252
+    from lean_python import check, sync
+
+    cli = args.lean_python or os.environ.get("LEAN_PYTHON_CLI")
+    try:
+        if command == "sync":
+            sync.sync_package(args.package, cli=cli)
+            return 0
+        if command == "check":
+            lock, _ = check.check_package(args.package, cli=cli)
+            rows = [(q, label, st) for q, e in sorted(lock.items()) for label, st in e["obligations"].items()]
+        else:
+            rows = check.status(args.package)
+    except sync.SyncError as e:
+        print(f"lean-py: {e}", file=sys.stderr)
+        return e.code
+    for q, label, st in rows:
+        print(f"{st:<10} {q} {label}")
+    if args.require == "proved" and any(st != "proved" for _, _, st in rows):
+        return 254
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{lean_python-0.1.0 → lean_python-0.2.0}/src/lean_python/embed.py

@@ -14,7 +14,7 @@ import sys
 import typing
 from dataclasses import dataclass, field
 
-GENERATOR_VERSION = "1"
+GENERATOR_VERSION = "2"
 
 
 class LeanBlockStale(RuntimeError):

lean_python-0.2.0/src/lean_python/lean/LeanPythonLib/Py.lean

@@ -0,0 +1,52 @@
+/-! The meaning of the Python operations the translated functions use (`lean-py check`).
+
+Failing operations (indexing, `//`, `%`, `assert`, `raise`) return `Py.M α = Except Py.Exc α`.
+Python's `int` is `Int`; `//` and `%` round towards negative infinity (`Int.fdiv`, `Int.fmod`). -/
+
+namespace Py
+
+/-- The exceptions of the translated functions. -/
+inductive Exc where
+  | indexError
+  | zeroDivisionError
+  | assertionError
+  | valueError (msg : String)
+  deriving Repr, DecidableEq
+
+abbrev M := Except Exc
+
+/-- `xs[i]`, with Python's negative indices. -/
+def getItem (xs : List α) (i : Int) : M α :=
+  let j := if i < 0 then i + xs.length else i
+  if 0 ≤ j then
+    match xs[j.toNat]? with
+    | some v => pure v
+    | none => throw .indexError
+  else throw .indexError
+
+/-- `a // b`. -/
+def floordiv (a b : Int) : M Int := if b = 0 then throw .zeroDivisionError else pure (Int.fdiv a b)
+
+/-- `a % b`. -/
+def mod (a b : Int) : M Int := if b = 0 then throw .zeroDivisionError else pure (Int.fmod a b)
+
+/-- `range(a, b)`. -/
+def range (a b : Int) : List Int := (List.range (b - a).toNat).map fun (k : Nat) => a + (k : Int)
+
+def abs (a : Int) : Int := if a < 0 then -a else a
+
+def len (xs : List α) : Int := xs.length
+
+def strLen (s : String) : Int := s.length
+
+def sum (xs : List Int) : Int := xs.foldl (· + ·) 0
+
+def assert (c : Bool) : M Unit := if c then pure () else throw .assertionError
+
+@[simp] theorem range_mem (a b i : Int) : i ∈ range a b ↔ a ≤ i ∧ i < b := by
+  simp only [range, List.mem_map, List.mem_range]
+  constructor
+  · rintro ⟨k, hk, rfl⟩; omega
+  · intro h; exact ⟨(i - a).toNat, by omega, by omega⟩
+
+end Py

{lean_python-0.1.0 → lean_python-0.2.0}/src/lean_python/marshal.py

@@ -701,9 +701,11 @@ def register_inductive(base, pairs):
 # Module assembly
 
 
-def attach(g, path, fn):
+def attach(g, path, fn, lean_name=None):
     fn.__name__ = path[-1]
     fn.__qualname__ = ".".join(path)
+    fn.__lean_name__ = lean_name
+    fn.__lean_module__ = g.get("__lean_module__")
     if len(path) == 1:
         g[path[0]] = fn
         return