lean-python 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

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/cli.py

@@ -10,12 +10,21 @@ import sys
 USAGE = """usage: lean-py <command> [parameters]
 
 commands:
-  sync   Check the Lean blocks of a package and generate their Python modules
+  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
 """
 
@@ -25,24 +34,38 @@ def main(argv=None):
     if not argv or argv[0] in ("help", "--help", "-h"):
         print(USAGE, end="")
         return 0
-    if argv[0] != "sync":
-        print(f"lean-py: unknown command {argv[0]!r} (see `lean-py help`)", file=sys.stderr)
+    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="lean-py sync", add_help=False, exit_on_error=False)
+    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 sync
+    from lean_python import check, sync
 
+    cli = args.lean_python or os.environ.get("LEAN_PYTHON_CLI")
     try:
-        sync.sync_package(args.package, cli=args.lean_python or os.environ.get("LEAN_PYTHON_CLI"))
+        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
 
 

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/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/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

lean_python/translate.py

@@ -0,0 +1,469 @@
+"""Translation of a typed, pure Python function into a Lean definition (``lean-py check``).
+
+The body becomes Lean ``do`` notation, which has Python's statements: ``let mut`` for local
+variables, ``for``/``while`` with ``break``/``continue``, ``if``, early ``return``. A function that
+may fail (indexing, ``//``, ``%``, ``assert``, ``raise``, or a call of such a function) returns
+``Py.M α`` (``Except Py.Exc α``); the others return ``α`` through ``Id.run do``. Python's ``int``
+is ``Int``; a ``Nat`` parameter is converted to ``Int`` on entry.
+"""
+
+import ast
+import inspect
+import textwrap
+import typing
+
+from pydantic import BaseModel
+
+from lean_python import models
+from lean_python.types import Nat
+
+
+class TranslateError(Exception):
+    def __init__(self, msg, fn=None, node=None):
+        where = ""
+        if fn is not None:
+            line = fn.__code__.co_firstlineno + (node.lineno - 1 if node is not None and hasattr(node, "lineno") else 0)
+            where = f"{fn.__code__.co_filename}:{line}: "
+        super().__init__(f"{where}{msg}")
+
+
+INT, BOOL, STR, FLOAT, NONE = "int", "bool", "str", "float", "none"
+
+
+def py_type(t, fn):
+    """A small type descriptor of a Python annotation."""
+    if t is Nat or (typing.get_origin(t) is typing.Annotated and typing.get_args(t)[0] is int):
+        return INT
+    if t is int:
+        return INT
+    if t is bool:
+        return BOOL
+    if t is str:
+        return STR
+    if t is float:
+        return FLOAT
+    if t is type(None) or t is None:
+        return NONE
+    origin = typing.get_origin(t)
+    if origin is list:
+        return ("list", py_type(typing.get_args(t)[0], fn))
+    if origin is tuple:
+        return ("tuple", tuple(py_type(a, fn) for a in typing.get_args(t)))
+    args = typing.get_args(t)
+    if args and type(None) in args and len(args) == 2:
+        return ("opt", py_type(next(a for a in args if a is not type(None)), fn))
+    if isinstance(t, type) and issubclass(t, BaseModel):
+        return ("model", t)
+    raise TranslateError(f"unsupported type {t!r}", fn)
+
+
+def lean_type(t):
+    if t == INT:
+        return "Int"
+    if t == BOOL:
+        return "Bool"
+    if t == STR:
+        return "String"
+    if t == FLOAT:
+        return "Float"
+    if t == NONE:
+        return "Unit"
+    kind = t[0]
+    if kind == "list":
+        return f"(List {lean_type(t[1])})"
+    if kind == "tuple":
+        return "(" + " × ".join(lean_type(a) for a in t[1]) + ")"
+    if kind == "opt":
+        return f"(Option {lean_type(t[1])})"
+    return models.class_name(t[1])
+
+
+def is_nat(annotation):
+    if annotation is Nat:
+        return True
+    if typing.get_origin(annotation) is typing.Annotated:
+        import annotated_types as at
+
+        base, *meta = typing.get_args(annotation)
+        return base is int and any(isinstance(m, at.Ge) and m.ge >= 0 for m in meta)
+    return False
+
+
+def field_info(cls, name):
+    """The Python type of a model field and whether its Lean field is a `Nat`."""
+    f = cls.model_fields.get(name)
+    if f is None:
+        raise TranslateError(f"{cls.__name__} has no field {name}")
+    t = py_type(f.annotation, None)
+    nat = False
+    if t == INT:
+        import annotated_types as at
+
+        lo = [m.ge for m in f.metadata if isinstance(m, at.Ge)] + [m.gt + 1 for m in f.metadata if isinstance(m, at.Gt)]
+        nat = is_nat(f.annotation) or (bool(lo) and max(lo) >= 0)
+    return t, nat
+
+
+class Fn:
+    """A function to translate: its signature and the names Lean knows it by."""
+
+    def __init__(self, fn, lean_name):
+        self.fn = fn
+        self.lean_name = lean_name
+        self.hints = typing.get_type_hints(fn, include_extras=True)
+        sig = inspect.signature(fn)
+        self.params = []
+        for p in sig.parameters.values():
+            if p.name not in self.hints:
+                raise TranslateError(f"parameter {p.name} of {fn.__qualname__} has no type annotation", fn)
+            self.params.append((p.name, self.hints[p.name]))
+        if "return" not in self.hints:
+            raise TranslateError(f"{fn.__qualname__} has no return annotation", fn)
+        self.ret = py_type(self.hints["return"], fn)
+        self.ret_nat = is_nat(self.hints["return"])
+        src = textwrap.dedent(inspect.getsource(fn))
+        tree = ast.parse(src)
+        self.node = next(n for n in tree.body if isinstance(n, ast.FunctionDef))
+        self.fails = None
+
+
+class Translator:
+    def __init__(self, fns):
+        self.fns = {f.fn.__name__: f for f in fns}
+        for f in fns:
+            f.fails = self._may_fail(f.node)
+        changed = True
+        while changed:
+            changed = False
+            for f in fns:
+                if not f.fails and any(
+                    isinstance(n, ast.Call)
+                    and isinstance(n.func, ast.Name)
+                    and n.func.id in self.fns
+                    and self.fns[n.func.id].fails
+                    for stmt in f.node.body
+                    for n in ast.walk(stmt)
+                ):
+                    f.fails = True
+                    changed = True
+
+    def _may_fail(self, node):
+        for stmt in node.body:
+            for n in ast.walk(stmt):
+                if isinstance(n, (ast.Subscript, ast.Assert, ast.Raise)):
+                    return True
+                if isinstance(n, ast.BinOp) and isinstance(n.op, (ast.FloorDiv, ast.Mod)):
+                    return True
+        return False
+
+    # -- expressions -------------------------------------------------------
+
+    def expr(self, e, env, fn):
+        """Lean source and type of a Python expression."""
+        f = fn.fn
+        if isinstance(e, ast.Constant):
+            v = e.value
+            if isinstance(v, bool):
+                return ("true" if v else "false"), BOOL
+            if isinstance(v, int):
+                return (f"({v} : Int)"), INT
+            if isinstance(v, str):
+                return json_str(v), STR
+            if isinstance(v, float):
+                return repr(v), FLOAT
+            if v is None:
+                return "none", ("opt", None)
+            raise TranslateError(f"unsupported constant {v!r}", f, e)
+        if isinstance(e, ast.Name):
+            if e.id not in env:
+                raise TranslateError(f"unknown name {e.id}", f, e)
+            return lean_ident(e.id), env[e.id]
+        if isinstance(e, ast.BinOp):
+            a, ta = self.expr(e.left, env, fn)
+            b, _ = self.expr(e.right, env, fn)
+            op = e.op
+            if isinstance(op, ast.Add):
+                if ta in (STR,) or (isinstance(ta, tuple) and ta[0] == "list"):
+                    return f"({a} ++ {b})", ta
+                return f"({a} + {b})", ta
+            if isinstance(op, ast.Sub):
+                return f"({a} - {b})", ta
+            if isinstance(op, ast.Mult):
+                return f"({a} * {b})", ta
+            if isinstance(op, ast.FloorDiv):
+                return f"(← Py.floordiv {a} {b})", INT
+            if isinstance(op, ast.Mod):
+                return f"(← Py.mod {a} {b})", INT
+            raise TranslateError(f"unsupported operator {type(op).__name__}", f, e)
+        if isinstance(e, ast.UnaryOp):
+            a, ta = self.expr(e.operand, env, fn)
+            if isinstance(e.op, ast.USub):
+                return f"(-{a})", ta
+            if isinstance(e.op, ast.Not):
+                return f"(!{a})", BOOL
+            raise TranslateError("unsupported unary operator", f, e)
+        if isinstance(e, ast.BoolOp):
+            parts = [self.expr(v, env, fn)[0] for v in e.values]
+            op = " && " if isinstance(e.op, ast.And) else " || "
+            return "(" + op.join(parts) + ")", BOOL
+        if isinstance(e, ast.Compare):
+            parts = []
+            left, _ = self.expr(e.left, env, fn)
+            for op, right in zip(e.ops, e.comparators, strict=True):
+                r, _ = self.expr(right, env, fn)
+                if isinstance(op, ast.In):
+                    parts.append(f"({r}.contains {left})")
+                elif isinstance(op, ast.NotIn):
+                    parts.append(f"(!{r}.contains {left})")
+                else:
+                    sym = {ast.Eq: "==", ast.NotEq: "!=", ast.Lt: "<", ast.LtE: "≤", ast.Gt: ">", ast.GtE: "≥"}.get(
+                        type(op)
+                    )
+                    if sym is None:
+                        raise TranslateError("unsupported comparison", f, e)
+                    parts.append(f"({left} {sym} {r})" if sym in ("==", "!=") else f"(decide ({left} {sym} {r}))")
+                left = r
+            return "(" + " && ".join(parts) + ")", BOOL
+        if isinstance(e, ast.IfExp):
+            c, _ = self.expr(e.test, env, fn)
+            a, ta = self.expr(e.body, env, fn)
+            b, _ = self.expr(e.orelse, env, fn)
+            return f"(if {c} then {a} else {b})", ta
+        if isinstance(e, ast.Attribute):
+            obj, to = self.expr(e.value, env, fn)
+            if isinstance(to, tuple) and to[0] == "model":
+                t, nat = field_info(to[1], e.attr)
+                s = f"{obj}.{lean_ident(e.attr)}"
+                return (f"({s} : Int)" if nat else s), t
+            raise TranslateError(f"attribute {e.attr} of a non-model value", f, e)
+        if isinstance(e, ast.Subscript):
+            obj, to = self.expr(e.value, env, fn)
+            if isinstance(to, tuple) and to[0] == "tuple" and isinstance(e.slice, ast.Constant):
+                i = e.slice.value
+                n = len(to[1])
+                proj = obj
+                for _ in range(i):
+                    proj = f"{proj}.2"
+                if i < n - 1:
+                    proj = f"{proj}.1"
+                return proj, to[1][i]
+            if isinstance(to, tuple) and to[0] == "list":
+                i, _ = self.expr(e.slice, env, fn)
+                return f"(← Py.getItem {obj} {i})", to[1]
+            raise TranslateError("unsupported subscript", f, e)
+        if isinstance(e, ast.Tuple):
+            parts = [self.expr(v, env, fn) for v in e.elts]
+            return "(" + ", ".join(p for p, _ in parts) + ")", ("tuple", tuple(t for _, t in parts))
+        if isinstance(e, ast.List):
+            parts = [self.expr(v, env, fn) for v in e.elts]
+            t = parts[0][1] if parts else INT
+            return "[" + ", ".join(p for p, _ in parts) + "]", ("list", t)
+        if isinstance(e, ast.ListComp):
+            return self.listcomp(e, env, fn)
+        if isinstance(e, ast.Call):
+            return self.call(e, env, fn)
+        raise TranslateError(f"unsupported expression {type(e).__name__}", f, e)
+
+    def listcomp(self, e, env, fn):
+        if len(e.generators) != 1 or e.generators[0].is_async or not isinstance(e.generators[0].target, ast.Name):
+            raise TranslateError("only list comprehensions with one `for x in ...` are supported", fn.fn, e)
+        g = e.generators[0]
+        src, ts = self.iterable(g.iter, env, fn)
+        x = g.target.id
+        inner = {**env, x: ts}
+        for cond in g.ifs:
+            c, _ = self.expr(cond, inner, fn)
+            src = f"({src}.filter (fun {lean_ident(x)} => {c}))"
+        body, t_body = self.expr(e.elt, inner, fn)
+        if "←" in body:
+            raise TranslateError("a list comprehension must not fail", fn.fn, e)
+        return f"({src}.map (fun {lean_ident(x)} => {body}))", ("list", t_body)
+
+    def iterable(self, e, env, fn):
+        if isinstance(e, ast.Call) and isinstance(e.func, ast.Name) and e.func.id == "range":
+            args = [self.expr(a, env, fn)[0] for a in e.args]
+            if len(args) == 1:
+                return f"(Py.range 0 {args[0]})", INT
+            if len(args) == 2:
+                return f"(Py.range {args[0]} {args[1]})", INT
+            raise TranslateError("range with a step is not supported", fn.fn, e)
+        src, t = self.expr(e, env, fn)
+        if isinstance(t, tuple) and t[0] == "list":
+            return src, t[1]
+        raise TranslateError("iteration over a non-list", fn.fn, e)
+
+    def call(self, e, env, fn):
+        f = fn.fn
+        if e.keywords and not (isinstance(e.func, ast.Name) and e.func.id not in ("len", "abs", "min", "max", "sum")):
+            raise TranslateError("keyword arguments are not supported", f, e)
+        if isinstance(e.func, ast.Name):
+            name = e.func.id
+            args = [self.expr(a, env, fn) for a in e.args]
+            if name == "len":
+                ((a, ta),) = args
+                return (f"(Py.strLen {a})" if ta == STR else f"(Py.len {a})"), INT
+            if name == "abs":
+                return f"(Py.abs {args[0][0]})", INT
+            if name in ("min", "max") and len(args) == 2:
+                return f"({name} {args[0][0]} {args[1][0]})", args[0][1]
+            if name == "sum":
+                return f"(Py.sum {args[0][0]})", INT
+            if name in self.fns:
+                target = self.fns[name]
+                call = f"({target.lean_name} {' '.join(self.arg_for(target, i, a) for i, (a, _) in enumerate(args))})"
+                return (f"(← {call})" if target.fails else call), target.ret
+        raise TranslateError("unsupported call (only len, abs, min, max, sum and @model functions of the module)", f, e)
+
+    def arg_for(self, target, i, a):
+        if is_nat(target.params[i][1]):
+            return f"({a}).toNat"
+        return a
+
+    # -- statements --------------------------------------------------------
+
+    def body(self, stmts, env, fn, indent, declared):
+        out = []
+        pad = "  " * indent
+        for s in stmts:
+            if isinstance(s, ast.Return):
+                if s.value is None:
+                    raise TranslateError("a function must return a value", fn.fn, s)
+                v, _ = self.expr(s.value, env, fn)
+                out.append(f"{pad}return {v}")
+            elif isinstance(s, (ast.Assign, ast.AnnAssign, ast.AugAssign)):
+                out.extend(self.assign(s, env, fn, pad, declared))
+            elif isinstance(s, ast.If):
+                c, _ = self.expr(s.test, env, fn)
+                out.append(f"{pad}if {c} then")
+                out.extend(self.body(s.body, env, fn, indent + 1, declared) or [f"{pad}  pure ()"])
+                if s.orelse:
+                    out.append(f"{pad}else")
+                    out.extend(self.body(s.orelse, env, fn, indent + 1, declared))
+            elif isinstance(s, ast.For):
+                if not isinstance(s.target, ast.Name):
+                    raise TranslateError("only `for x in ...` is supported", fn.fn, s)
+                src, t = self.iterable(s.iter, env, fn)
+                inner = dict(env)
+                inner[s.target.id] = t
+                out.append(f"{pad}for {lean_ident(s.target.id)} in {src} do")
+                out.extend(self.body(s.body, inner, fn, indent + 1, declared) or [f"{pad}  pure ()"])
+            elif isinstance(s, ast.While):
+                c, _ = self.expr(s.test, env, fn)
+                out.append(f"{pad}while {c} do")
+                out.extend(self.body(s.body, env, fn, indent + 1, declared) or [f"{pad}  pure ()"])
+            elif isinstance(s, ast.Break):
+                out.append(f"{pad}break")
+            elif isinstance(s, ast.Continue):
+                out.append(f"{pad}continue")
+            elif isinstance(s, ast.Pass):
+                out.append(f"{pad}pure ()")
+            elif isinstance(s, ast.Assert):
+                c, _ = self.expr(s.test, env, fn)
+                out.append(f"{pad}Py.assert {c}")
+            elif isinstance(s, ast.Raise):
+                msg = '""'
+                if isinstance(s.exc, ast.Call) and s.exc.args and isinstance(s.exc.args[0], ast.Constant):
+                    msg = json_str(str(s.exc.args[0].value))
+                out.append(f"{pad}throw (.valueError {msg})")
+            elif (
+                isinstance(s, ast.Expr)
+                and isinstance(s.value, ast.Call)
+                and isinstance(s.value.func, ast.Attribute)
+                and s.value.func.attr == "append"
+            ):
+                target = s.value.func.value
+                if not (isinstance(target, ast.Name) and target.id in declared):
+                    raise TranslateError("append only to a list created in the function", fn.fn, s)
+                v, _ = self.expr(s.value.args[0], env, fn)
+                out.append(f"{pad}{lean_ident(target.id)} := {lean_ident(target.id)} ++ [{v}]")
+            elif isinstance(s, ast.Expr) and isinstance(s.value, ast.Constant) and isinstance(s.value.value, str):
+                continue
+            else:
+                raise TranslateError(f"unsupported statement {type(s).__name__}", fn.fn, s)
+        return out
+
+    def assign(self, s, env, fn, pad, declared):
+        if isinstance(s, ast.AugAssign):
+            target = s.target
+            op = {ast.Add: "+", ast.Sub: "-", ast.Mult: "*"}.get(type(s.op))
+            if not isinstance(target, ast.Name) or target.id not in declared:
+                raise TranslateError("augmented assignment to an undefined local", fn.fn, s)
+            v, tv = self.expr(s.value, env, fn)
+            t = env[target.id]
+            if op == "+" and (t == STR or (isinstance(t, tuple) and t[0] == "list")):
+                op = "++"
+            if op is None:
+                if isinstance(s.op, ast.FloorDiv):
+                    return [f"{pad}{lean_ident(target.id)} := (← Py.floordiv {lean_ident(target.id)} {v})"]
+                if isinstance(s.op, ast.Mod):
+                    return [f"{pad}{lean_ident(target.id)} := (← Py.mod {lean_ident(target.id)} {v})"]
+                raise TranslateError("unsupported augmented assignment", fn.fn, s)
+            return [f"{pad}{lean_ident(target.id)} := {lean_ident(target.id)} {op} {v}"]
+        targets = [s.target] if isinstance(s, ast.AnnAssign) else s.targets
+        if len(targets) != 1:
+            raise TranslateError("chained assignment is not supported", fn.fn, s)
+        target = targets[0]
+        v, tv = self.expr(s.value, env, fn)
+        if isinstance(s, ast.AnnAssign):
+            tv = py_type(eval(compile(ast.Expression(s.annotation), "<annotation>", "eval"), fn.fn.__globals__), fn.fn)
+        names = [target] if isinstance(target, ast.Name) else (target.elts if isinstance(target, ast.Tuple) else None)
+        if names is None or not all(isinstance(n, ast.Name) for n in names):
+            raise TranslateError("only assignment to names is supported", fn.fn, s)
+        if isinstance(target, ast.Tuple):
+            types = tv[1] if isinstance(tv, tuple) and tv[0] == "tuple" else [None] * len(names)
+            out = []
+            tmp = "__t"
+            out.append(f"{pad}let {tmp} := {v}")
+            for i, (n, t) in enumerate(zip(names, types, strict=True)):
+                proj = tmp + ".2" * i + (".1" if i < len(names) - 1 else "")
+                out.extend(self._bind(n.id, proj, t, env, pad, declared))
+            return out
+        return self._bind(target.id, v, tv, env, pad, declared)
+
+    def _bind(self, name, v, t, env, pad, declared):
+        if name in declared:
+            return [f"{pad}{lean_ident(name)} := {v}"]
+        declared.add(name)
+        env[name] = t
+        ty = f" : {lean_type(t)}" if t is not None and not (isinstance(t, tuple) and t[1] is None) else ""
+        return [f"{pad}let mut {lean_ident(name)}{ty} := {v}"]
+
+    # -- definitions -------------------------------------------------------
+
+    def definition(self, fn):
+        env = {}
+        binders = []
+        prelude = []
+        for name, ann in fn.params:
+            t = py_type(ann, fn.fn)
+            env[name] = t
+            if is_nat(ann):
+                binders.append(f"({lean_ident(name)} : Nat)")
+                prelude.append(f"  let {lean_ident(name)} : Int := {lean_ident(name)}")
+            else:
+                binders.append(f"({lean_ident(name)} : {lean_type(t)})")
+        declared = set()
+        ret = lean_type(fn.ret)
+        rty = f"Py.M {ret}" if fn.fails else ret
+        head = "do" if fn.fails else "Id.run do"
+        lines = self.body(fn.node.body, env, fn, 1, declared)
+        doc = f"/-- `{fn.fn.__module__}.{fn.fn.__qualname__}`, translated from Python. -/"
+        return "\n".join([doc, f"def {fn.lean_name} {' '.join(binders)} : {rty} := {head}", *prelude, *lines])
+
+
+def lean_ident(name):
+    return models.ident(name)
+
+
+def json_str(s):
+    out = '"'
+    for c in s:
+        if c == '"':
+            out += '\\"'
+        elif c == "\\":
+            out += "\\\\"
+        elif c == "\n":
+            out += "\\n"
+        else:
+            out += c
+    return out + '"'

lean_python/verify.py

@@ -0,0 +1,147 @@
+"""``@model``: bind a Python function to Lean specifications.
+
+``@model(refines=spec.f)`` says the function computes ``spec.f`` (a function of a ``lean(...)``
+block); ``requires=`` and ``ensures=`` name ``Bool`` functions of blocks (the precondition takes
+the arguments, the postcondition the arguments and the result). ``lean-py check`` translates the
+function into Lean and reports whether the obligations are proved; ``check_model`` runs the same
+specifications as a property test with Hypothesis. The decorator returns the function unchanged.
+"""
+
+import inspect
+import typing
+
+REGISTRY = []
+
+
+class ModelSpec:
+    def __init__(self, fn, refines, requires, ensures):
+        self.fn = fn
+        self.refines = refines
+        self.requires = requires
+        if ensures is None:
+            self.ensures = {}
+        elif isinstance(ensures, dict):
+            self.ensures = dict(ensures)
+        else:
+            self.ensures = {"ensures": ensures}
+
+    @property
+    def qualname(self):
+        return f"{self.fn.__module__}:{self.fn.__qualname__}"
+
+    def specs(self):
+        out = {}
+        if self.refines is not None:
+            out["refines"] = self.refines
+        if self.requires is not None:
+            out["requires"] = self.requires
+        out.update(self.ensures)
+        return out
+
+
+def model(*, refines=None, requires=None, ensures=None):
+    """Binds the decorated function to Lean specifications (see the module docstring)."""
+
+    def deco(fn):
+        spec = ModelSpec(fn, refines, requires, ensures)
+        fn.__lean_model__ = spec
+        REGISTRY.append(spec)
+        return fn
+
+    return deco
+
+
+def models_of(module):
+    return [v.__lean_model__ for v in vars(module).values() if callable(v) and hasattr(v, "__lean_model__")]
+
+
+# ---------------------------------------------------------------------------
+# Property tests
+
+
+def strategy(annotation, metadata=()):
+    """A Hypothesis strategy of the values of a parameter or field type."""
+    import annotated_types as at
+    from hypothesis import strategies as st
+    from pydantic import BaseModel
+
+    metadata = list(metadata)
+    while typing.get_origin(annotation) is typing.Annotated:
+        annotation, *more = typing.get_args(annotation)
+        metadata.extend(more)
+    if annotation is int:
+        lo = hi = None
+        for m in metadata:
+            if isinstance(m, at.Ge):
+                lo = m.ge if lo is None else max(lo, m.ge)
+            elif isinstance(m, at.Gt):
+                lo = m.gt + 1 if lo is None else max(lo, m.gt + 1)
+            elif isinstance(m, at.Le):
+                hi = m.le if hi is None else min(hi, m.le)
+            elif isinstance(m, at.Lt):
+                hi = m.lt - 1 if hi is None else min(hi, m.lt - 1)
+        return st.integers(min_value=lo if lo is not None else -1000, max_value=hi if hi is not None else 1000)
+    if annotation is bool:
+        return st.booleans()
+    if annotation is str:
+        lo = max([m.min_length for m in metadata if isinstance(m, at.MinLen)], default=0)
+        hi = min([m.max_length for m in metadata if isinstance(m, at.MaxLen)], default=lo + 8)
+        return st.text(min_size=lo, max_size=hi)
+    if annotation is float:
+        return st.floats(allow_nan=False, allow_infinity=False, width=64)
+    origin = typing.get_origin(annotation)
+    if origin is list:
+        (a,) = typing.get_args(annotation)
+        return st.lists(strategy(a), max_size=8)
+    if origin is tuple:
+        return st.tuples(*(strategy(a) for a in typing.get_args(annotation)))
+    args = typing.get_args(annotation)
+    if args and type(None) in args:
+        rest = [a for a in args if a is not type(None)]
+        return st.none() | st.one_of(*(strategy(a) for a in rest))
+    if isinstance(annotation, type) and issubclass(annotation, BaseModel):
+        fields = {n: strategy(f.annotation, f.metadata) for n, f in annotation.model_fields.items()}
+        return st.builds(annotation, **fields)
+    raise TypeError(f"no strategy for {annotation!r}")
+
+
+class PropertyFailure(AssertionError):
+    pass
+
+
+def check_model(fn, max_examples=200):
+    """Runs the function against its specifications on generated arguments; raises on a counterexample."""
+    from hypothesis import given, settings
+    from hypothesis import strategies as st
+
+    spec = fn.__lean_model__
+    hints = typing.get_type_hints(fn, include_extras=True)
+    params = list(inspect.signature(fn).parameters)
+    strategies = st.tuples(*(strategy(hints[p]) for p in params))
+
+    @settings(max_examples=max_examples, deadline=None, database=None)
+    @given(strategies)
+    def run(args):
+        from hypothesis import assume
+
+        if spec.requires is not None:
+            assume(spec.requires(*args))
+        try:
+            result = fn(*args)
+        except Exception as e:  # noqa: BLE001
+            raise PropertyFailure(f"{fn.__qualname__}{args} raised {e!r}") from None
+        if spec.refines is not None:
+            expected = spec.refines(*args)
+            if result != expected:
+                raise PropertyFailure(f"{fn.__qualname__}{args} = {result!r}, the spec gives {expected!r}")
+        for label, e in spec.ensures.items():
+            if not e(*args, result):
+                raise PropertyFailure(f"{fn.__qualname__}{args} = {result!r} breaks {label}")
+
+    run()
+
+
+def check_module(module, max_examples=200):
+    """``check_model`` for every ``@model`` function of the module."""
+    for spec in models_of(module):
+        check_model(spec.fn, max_examples)

{lean_python-0.1.0.dist-info → lean_python-0.2.0.dist-info}/METADATA

@@ -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.2.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+lean_python/__init__.py,sha256=w09gaS4QGgFS0pM8Y3aSVMfQm-iHgEG_Sm_RqwKh--I,182
+lean_python/check.py,sha256=uQkstmWq7mRSPxPW6Ac4yCCFqGacAZFBiCx19Y_XT6k,11129
+lean_python/cli.py,sha256=r68dhTW7X1jUNx1GrJEsuXpx-kU9VGhCsbV0Xy5Ih9w,2575
+lean_python/embed.py,sha256=4gKW2XM6EGJkJOQ8ghpnOAb_k_8GlJWscrAZVaVX2a8,3996
+lean_python/io.py,sha256=l7LErXI_DhACZf9Jaef3r5Stqh4PdUk-bCNTo91BLE0,356
+lean_python/io_externs.py,sha256=lI7oK7WTMjYV1JxaNzEnscVMunME_5SYoGDz3Qq1GSM,29807
+lean_python/marshal.py,sha256=LBUL3bC9SoQFow6Kbj3kMyoCHfDvmQslrJnJW3SkqvQ,20877
+lean_python/models.py,sha256=wunIZ9hOG-8H3shdRClLN7pR6Kmofo9zlPcL3Hr0rq0,10940
+lean_python/runtime.py,sha256=Fr3R6x-kZUW2H1_NwbwI_LI97OUmMQ8Q0smnPKyyAAc,28439
+lean_python/sync.py,sha256=JKJj3IWQlrqjTvK_-puPuF1Nt0LMumywUilUJANqhfc,9304
+lean_python/translate.py,sha256=9K08bKrWt8yCYwdH8LutuuwMX9kLRqIGhUaI5BbKzYI,20596
+lean_python/types.py,sha256=qOhcwe1lYGD17OHW_A4LzfGi2bcPovTANTggaJwG-FM,843
+lean_python/verify.py,sha256=KmIdkIzNRF3AHvtdyw-XIGcnws2RhwObBF_AGycxDXY,5525
+lean_python/lean/LeanPythonLib/Py.lean,sha256=NCx9mxRNnI7_wsK_FEh2eqkp6_EO9buXZrnZNiDrJmk,1658
+lean_python-0.2.0.dist-info/METADATA,sha256=ghnqqVdM8sT4bk6cy0s8iKolBm39pDjdYjmfBJBCRQs,13387
+lean_python-0.2.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+lean_python-0.2.0.dist-info/entry_points.txt,sha256=BD86jsJKikYcvsZse4ysbLvvN7TuGogwmiUZZwu7FBo,49
+lean_python-0.2.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+lean_python-0.2.0.dist-info/RECORD,,

lean_python-0.1.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-lean_python/__init__.py,sha256=w09gaS4QGgFS0pM8Y3aSVMfQm-iHgEG_Sm_RqwKh--I,182
-lean_python/cli.py,sha256=ERwAkhhFJV32BqS3-lDHPYi0UiCbydyEFI0ZlHobmsk,1559
-lean_python/embed.py,sha256=WBEWYN7r3xFbSNLgvRRfn-6qhcR5Q1h1ge8KwQ5yyfE,3996
-lean_python/io.py,sha256=l7LErXI_DhACZf9Jaef3r5Stqh4PdUk-bCNTo91BLE0,356
-lean_python/io_externs.py,sha256=lI7oK7WTMjYV1JxaNzEnscVMunME_5SYoGDz3Qq1GSM,29807
-lean_python/marshal.py,sha256=WIY3yJtnIMvym8_jraY8F1tW8x1iYqRkcS4W_FGWwLM,20778
-lean_python/models.py,sha256=wunIZ9hOG-8H3shdRClLN7pR6Kmofo9zlPcL3Hr0rq0,10940
-lean_python/runtime.py,sha256=Fr3R6x-kZUW2H1_NwbwI_LI97OUmMQ8Q0smnPKyyAAc,28439
-lean_python/sync.py,sha256=JKJj3IWQlrqjTvK_-puPuF1Nt0LMumywUilUJANqhfc,9304
-lean_python/types.py,sha256=qOhcwe1lYGD17OHW_A4LzfGi2bcPovTANTggaJwG-FM,843
-lean_python-0.1.0.dist-info/METADATA,sha256=7IosM2WL2AjIjMM0CYy015gHPmkViqxr_vT075QI1gw,9775
-lean_python-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
-lean_python-0.1.0.dist-info/entry_points.txt,sha256=BD86jsJKikYcvsZse4ysbLvvN7TuGogwmiUZZwu7FBo,49
-lean_python-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-lean_python-0.1.0.dist-info/RECORD,,