max/crosslang
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Monorepo: golang-lean (TGC) + octive-lean (TOC) + tsm-lean (TSM) + common-lean (cross-language apex).
4 commits 1 branch 0 tags 190 KiB
Find a file
Maximus Gorog ed636a1aa2 Prove preservation theorem for TGC big-step semantics. 
GolangLean/Core/Preservation.lean:

theorem preservation:
  HasType Γ e T -> HasTypeH ht h -> HasTypeEnv ht env Γ ->
  BigStep h env e v h' ->
    ∃ ht', HeapTy.extends ht ht' /\ HasTypeH ht' h' /\
            HasTypeV ht' v T /\ HasTypeEnv ht' env Γ

The standard big-step type-soundness result: well-typed terminating
programs produce well-typed values, with heap conformance preserved.
Proof is by induction on the big-step derivation, fourteen cases.

Supporting infrastructure:
  HeapTy.extends_push    - heap-typing extends across a push
  HasTypeH.push          - heap conformance preserved by push
  HasTypeH.setIfInBounds - heap conformance preserved by in-bounds update
  binop_apply_sound      - operator typing matches operator semantics

The closure case (appR) uses the mutual HasTypeV/HasTypeEnv weakening
lemmas from TypeSoundness to thread heap-typings across the three
sub-derivations. The assign case (assignR) uses the heap-update
lemma to preserve conformance. The if-cases collapse the cross-rule
(ifT vs ifF) ambiguity via Bool.noConfusion on the condition's IH.

Zero sorries / axioms / admits across the project. Full lake build clean.
2026-05-10 04:05:08 -06:00
corpus Initial scaffold: Lean 4 reimplementation of Go. 2026-05-10 02:12:19 -06:00
GolangLean Prove preservation theorem for TGC big-step semantics. 2026-05-10 04:05:08 -06:00
.gitignore Initial scaffold: Lean 4 reimplementation of Go. 2026-05-10 02:12:19 -06:00
CorpusCheck.lean Initial scaffold: Lean 4 reimplementation of Go. 2026-05-10 02:12:19 -06:00
GolangLean.lean Prove preservation theorem for TGC big-step semantics. 2026-05-10 04:05:08 -06:00
justfile Initial scaffold: Lean 4 reimplementation of Go. 2026-05-10 02:12:19 -06:00
lake-manifest.json Initial scaffold: Lean 4 reimplementation of Go. 2026-05-10 02:12:19 -06:00
lakefile.toml Initial scaffold: Lean 4 reimplementation of Go. 2026-05-10 02:12:19 -06:00
lean-toolchain Initial scaffold: Lean 4 reimplementation of Go. 2026-05-10 02:12:19 -06:00
Main.lean Initial scaffold: Lean 4 reimplementation of Go. 2026-05-10 02:12:19 -06:00
README.md Initial scaffold: Lean 4 reimplementation of Go. 2026-05-10 02:12:19 -06:00

README.md

golang-lean

A Lean 4 reimplementation of the Go programming language — using the upstream reference compiler/parser as the source of truth, the way octive-lean uses GNU Octave.

Built parallel to octive-lean. Goals:

  1. Working Go interpreter for a useful subset (start: pure Go, no goroutines).
  2. Formal semantics layered on top: BigStep / PureEval / ValueEquiv so proofs about Go programs are first-class.
  3. Cross-language layer — once both this and octive-lean have a real evaluator and big-step semantics, factor a shared core out of two concrete points rather than guessing the abstraction in advance.

Build

lake build

Requires the Lean toolchain pinned in lean-toolchain. elan will pick it up automatically.

Run

# REPL stub
lake exe golang-lean

# Run a .go script (not yet implemented)
lake exe golang-lean path/to/script.go

# Verify the corpus against expected outputs
lake build corpus-check
lake exe corpus-check

Layout

Path What's there
GolangLean/ Library: Token, Scanner, AST, Parser, Value, Env, Eval, Builtins, REPL, BigStep, PureEval, ValueEquiv, Error
Main.lean Entry point — REPL or file runner
CorpusCheck.lean Test driver for corpus/
corpus/ .go test cases paired with .expected outputs
go-upstream/ Shallow clone of golang/go (gitignored, used as reference)

Status

Scaffold. Module skeleton in place. Token and AST are real ports of go/token and go/ast. Scanner / Parser / Eval are stubs that throw notImpl so the project compiles.

Next:

  1. Implement Scanner.scan against go-upstream/src/go/scanner/scanner.go.
  2. Implement Parser.parseFile recursive-descent against go-upstream/src/go/parser/parser.go.
  3. Implement Eval for the pure subset (no goroutines, no defer, no panic/recover).
  4. Mirror octive-lean's BigStep / ValueEquiv triple.

Reference

go-upstream/ is a shallow clone of https://github.com/golang/go. Key paths:

Path What's there
go-upstream/src/go/token/ Token kinds, position tracking
go-upstream/src/go/scanner/ Lexer
go-upstream/src/go/ast/ AST node types
go-upstream/src/go/parser/ Recursive-descent parser
go-upstream/src/go/types/ Type-checker (later)
go-upstream/src/runtime/ Runtime / scheduler / GC (much later)