Monorepo: golang-lean (TGC) + octive-lean (TOC) + tsm-lean (TSM) + common-lean (cross-language apex).
d86d500b4f
OctiveLean/Core/Preservation.lean — the TOC analogue of TGC's
preservation. Statement:
HasType Γ e T ∧ HasTypeEnv env Γ ∧ BigStep env e v env'
⟹ HasTypeV v T ∧ HasTypeEnv env' Γ
No heap-typing extension (Octave has no heap). Γ is unchanged across
big-steps (assign requires x already typed).
Three structural changes were required to make preservation provable
under env-mutation, all small:
* letIn semantics shifted to scope-restoring: BigStep.letInR now
returns env1 (the env after evaluating the bound expression)
rather than env2 (after the body). This drops body's mutations
at scope-end, matching the lambda-calculus tradition. Determinism
and Eval updated to match.
* HasTypeV.vClos uses a two-part premise (he_dom + he_typed)
instead of nested ∃ — the kernel rejects nested inductive
parameters with locally-bound vars. The two parts are equivalent
to HasTypeEnv via the new HasTypeV.vClos_to_env inversion lemma.
* Inversion via HasTypeV.vClos_to_env exposes the closure's typing
context as an existential — preservation's appR case uses this
to construct the body's HasTypeEnv via extend_letIn.
The cross-language symmetry that emerged:
TGC preservation : threads heap-typings, weakens via extension.
TOC preservation : threads env directly, no extension needed.
In both, the rule cases collapse into the same three structural
shapes — terminal, IH-chain, contradiction-collapse. The case bodies
differ in HOW state is propagated (heap-typing for TGC, env for TOC)
but the SHAPE of each case is identical. That's the cross-language
abstraction speaking.
Zero sorries / axioms / admits across both projects.
|
||
|---|---|---|
| .github/workflows | ||
| corpus | ||
| OctiveLean | ||
| widget/js | ||
| .editorconfig | ||
| .gitattributes | ||
| .gitignore | ||
| CONTRIBUTING.md | ||
| CorpusCheck.lean | ||
| justfile | ||
| lake-manifest.json | ||
| lakefile.toml | ||
| lean-toolchain | ||
| Main.lean | ||
| NumericalTutorial.lean | ||
| OctiveLean.lean | ||
| PlotDemo.lean | ||
| README.md | ||
| RosettaStone.lean | ||
| tutorial.m | ||
octive-lean
A Lean 4 reimplementation of GNU Octave — the MATLAB-compatible numerical language — aiming to be more versatile than upstream.
Build
lake build
Requires the Lean toolchain pinned in lean-toolchain. elan will pick it up automatically.
Run
# REPL
lake exe octive-lean
# Run an .m script
lake exe octive-lean path/to/script.m
# Verify the corpus against expected outputs
lake build corpus-check
lake exe corpus-check
Layout
| Path | What's there |
|---|---|
OctiveLean/ |
Library: Lexer, Parser, AST, Eval, Builtins, REPL, BigStep, PlotSVG, … |
Main.lean |
Entry point — REPL or file runner |
CorpusCheck.lean |
Test driver for corpus/ |
corpus/ |
.m test cases paired with .expected outputs |
NumericalTutorial.lean, RosettaStone.lean |
Lean-side tutorials and Octave⇄Lean translations |
PlotDemo.lean, widget/ |
Plotting via ProofWidgets + SVG |
octave-upstream/ |
Shallow clone of GNU Octave (gitignored, used as reference) |
Status
Working interpreter: matrices, arithmetic, control flow, functions (incl. recursion, closures, anonymous @(x)), cell arrays, structs, printf-family, REPL, file execution. See corpus/ for what's covered.
Tests
lake build && lake exe corpus-check
Pass --update to regenerate .expected files after intentional behavior changes.