rename: the language is now Lumbda (lumbda.com). Phase 1: prose
Language gets a proper name. Tagline per fox: Lumbda — a just-in-time lambda language. Fast from first principles, workloads migratable across basic UNIX systems. Phase 1 scope: prose mentions of the language in the whitepaper, README, and CLAUDE.md. File paths, binary names, and the repo directory still use the historical "uncommonlisp" identifier — those are Phase 2 (needs GitLab coordination + build-path edits). - Whitepaper title "Feedback Is All You Need" → "Lumbda", with the prior title preserved as a subtitle thread. New header linkblock lists lumbda.com first, then uncloseai.com and permacomputer.com. - README.md opens with the tagline, points at lumbda.com. - CLAUDE.md banner clarifies Lumbda-the-language vs the historical repo/binary names. - ~25 prose mentions of "uncommonlisp" in the paper are now "Lumbda"; file-path refs (python3 uncommonlisp.py, ./c/uncommonlisp, uncommonlisp.py, asm/uncommonlisp.s) unchanged. - Benchmark methodology table widened slightly to fit the new 6-char label. No behavior change, no benchmarks rerun, 975 tests still pass.
This commit is contained in:
parent
aff292ebc8
commit
2d21a671c9
4 changed files with 655 additions and 636 deletions
|
|
@ -1,6 +1,6 @@
|
|||
# Agent Blackops
|
||||
# Agent Blackops — Lumbda repo
|
||||
|
||||
This repo is operated by **agent blackops** — ml agent for fox/timehexon on the unsandbox/unturf/permacomputer platform.
|
||||
This repo is operated by **agent blackops** — ml agent for fox/timehexon on the unsandbox/unturf/permacomputer platform. **Lumbda** is the language (home: lumbda.com); the repo directory and binaries still use the historical name `uncommonlisp` until the filesystem rename ships in a later phase.
|
||||
|
||||
## Identity
|
||||
|
||||
|
|
@ -103,7 +103,7 @@ Additional rules:
|
|||
|
||||
- `ulimit -v` affects only the shell it runs in and its children, so
|
||||
it cannot degrade anyone else's agents. Always set it before
|
||||
backgrounding any uncommonlisp process.
|
||||
backgrounding any Lumbda process.
|
||||
- Bound iterations **inside the .lsp** (e.g. `*max-requests* = 50000`
|
||||
in `examples/http-server.lsp`). Never raise for long-running tests.
|
||||
- Use `pkill -u "$USER" -f <pattern>` not `pkill` alone — others may
|
||||
|
|
|
|||
12
README.md
12
README.md
|
|
@ -1,6 +1,10 @@
|
|||
# uncommonlisp
|
||||
# Lumbda
|
||||
|
||||
A Scheme interpreter in one Python file, with a bytecode compiler.
|
||||
**A just-in-time lambda language — fast from first principles, workloads migratable across basic UNIX systems.**
|
||||
|
||||
Three implementations of R7RS Scheme (Python bytecode VM, C with x86_64 JIT, pure x86_64 assembly) sharing one wire format: Scheme source itself. Continuations within a process, portal files across processes, S-expressions across implementations, TCP sockets across machines.
|
||||
|
||||
Home: [lumbda.com](https://lumbda.com)
|
||||
|
||||
```
|
||||
λ> (define (fib n)
|
||||
|
|
@ -21,7 +25,7 @@ python3 uncommonlisp.py --fast script.lsp # auto-compile (7-19x faster)
|
|||
|
||||
## Bytecode compiler
|
||||
|
||||
uncommonlisp includes a stack-based bytecode compiler and VM. Enable it with `--fast` or `(auto-compile! #t)`:
|
||||
Lumbda includes a stack-based bytecode compiler and VM. Enable it with `--fast` or `(auto-compile! #t)`:
|
||||
|
||||
```bash
|
||||
python3 uncommonlisp.py --fast examples/fibonacci.lsp
|
||||
|
|
@ -160,7 +164,7 @@ Three approaches, benchmarked:
|
|||
| Approach | Time | Guarantee |
|
||||
|----------|------|-----------|
|
||||
| Python (numerical) | 0.04s | 1e-10 tolerance |
|
||||
| uncommonlisp (numerical) | 59s | 1e-10 tolerance |
|
||||
| Lumbda (numerical) | 59s | 1e-10 tolerance |
|
||||
| Lean 4 (formal proof) | 1.5s | kernel-verified |
|
||||
|
||||
The formal proof is 40x faster than brute-force search with infinitely stronger
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
|
|
@ -24,16 +24,16 @@
|
|||
:width: 42%
|
||||
:align: center
|
||||
|
||||
Feedback Is All You Need
|
||||
========================
|
||||
Lumbda
|
||||
======
|
||||
|
||||
.. class:: center
|
||||
|
||||
**A Complete Scheme VM in One File: Continuations, Bytecode, & the EML Universality Proof**
|
||||
**A just-in-time lambda language — fast from first principles, workloads migratable across basic UNIX systems.**
|
||||
|
||||
.. class:: center
|
||||
|
||||
*How an explicit frame stack with full call/cc builds a production Lisp from feedback alone.*
|
||||
*Feedback is all you need: continuations within a process, portals across processes, S-expressions across implementations, sockets across machines.*
|
||||
|
||||
.. class:: center
|
||||
|
||||
|
|
@ -41,7 +41,7 @@ Feedback Is All You Need
|
|||
|
||||
.. class:: center
|
||||
|
||||
`uncloseai.com <https://uncloseai.com>`_ · `permacomputer.com <https://www.permacomputer.com>`_
|
||||
`lumbda.com <https://lumbda.com>`_ · `uncloseai.com <https://uncloseai.com>`_ · `permacomputer.com <https://www.permacomputer.com>`_
|
||||
|
||||
.. class:: center
|
||||
|
||||
|
|
@ -58,7 +58,7 @@ Abstract
|
|||
|
||||
A programming language needs one primitive to become universal: feedback. A function that receives its own continuation can loop, branch, yield, checkpoint, resume, & migrate. Every control flow pattern reduces to a continuation captured & invoked. Extend feedback across time (portals) & across implementations (source-as-wire-format) and you recover the full scope of computation without new primitives.
|
||||
|
||||
**uncommonlisp** proves this by implementing R7RS Scheme three ways:
|
||||
**Lumbda** proves this by implementing R7RS Scheme three ways:
|
||||
|
||||
- **Python bytecode VM** — 3,743 lines, full first-class continuations, JSON portal, reference implementation
|
||||
- **C interpreter + x86_64 JIT** — 9,164 lines of runtime C (plus ~1,200 in the test harness), 7--10× faster than CPython on recursive workloads, JSON portal
|
||||
|
|
@ -74,7 +74,7 @@ All three share one interchange format: **Scheme source itself**. An S-expressio
|
|||
|
||||
975 verified assertions pass identically across the three implementations (571 Python unit, 132 asm, 189 shared Python+C functional, 83 C unit). Every implementation consumes every format it can reach; mismatch cases (wrong format, truncated input, missing file, corrupt header) degrade gracefully with ``#f`` or a clean error.
|
||||
|
||||
The paper further presents the EML universality proof: a single operator ``eml(x, y) = exp(x) - ln(y)`` with the constant 1 generates all elementary functions (exp, ln, arithmetic, negation, complex plane access, trigonometry). Verified numerically in Python, verified in uncommonlisp's own bytecode, & proven formally in Lean 4 with zero ``sorry``.
|
||||
The paper further presents the EML universality proof: a single operator ``eml(x, y) = exp(x) - ln(y)`` with the constant 1 generates all elementary functions (exp, ln, arithmetic, negation, complex plane access, trigonometry). Verified numerically in Python, verified in Lumbda's own bytecode, & proven formally in Lean 4 with zero ``sorry``.
|
||||
|
||||
Feedback is the primitive. Continuations are its mechanism in time. Portals are its mechanism across time. S-expressions are its mechanism across implementations. Sockets are its mechanism across machines. One file is the proof — by three translations.
|
||||
|
||||
|
|
@ -86,7 +86,7 @@ Most language implementations treat control flow as a tree of special cases. ``i
|
|||
|
||||
The insight: every control flow pattern is a special case of feedback. A loop feeds the tail position back to the head. A generator feeds a value out & a resumption point in. An exception feeds control to the nearest handler. A checkpoint feeds the entire machine state to storage. If the language exposes feedback as a first-class primitive, all these patterns compose without special cases.
|
||||
|
||||
Scheme discovered this in 1975 with ``call-with-current-continuation``. But most Scheme implementations compromise: they limit continuations to escape-only, implement them via ``setjmp``/``longjmp`` on the C stack, or require CPS transformation that obscures the source. uncommonlisp takes a different path: an explicit frame stack that makes continuations a data structure, not a stack manipulation trick.
|
||||
Scheme discovered this in 1975 with ``call-with-current-continuation``. But most Scheme implementations compromise: they limit continuations to escape-only, implement them via ``setjmp``/``longjmp`` on the C stack, or require CPS transformation that obscures the source. Lumbda takes a different path: an explicit frame stack that makes continuations a data structure, not a stack manipulation trick.
|
||||
|
||||
|
||||
2. Architecture: One File, Two Evaluators
|
||||
|
|
@ -98,7 +98,7 @@ Scheme discovered this in 1975 with ``call-with-current-continuation``. But most
|
|||
|
||||
*Python implementation: source → reader → (tree-walker | bytecode compiler → bytecode VM) → builtins / env / continuations / portal. The two evaluators share the type system and environment model; the bytecode path diverges via a compiler and explicit frame stack.*
|
||||
|
||||
uncommonlisp implements two evaluation strategies in a single 3,743-line Python file:
|
||||
Lumbda implements two evaluation strategies in a single 3,743-line Python file:
|
||||
|
||||
**Tree-walking interpreter** (``leval``): The default mode. Walks the AST directly, handles all forms including macro definitions, record types, & dynamic features. Suitable for interactive development & complex metaprogramming.
|
||||
|
||||
|
|
@ -197,7 +197,7 @@ When ``OP_RETURN`` executes:
|
|||
;; This runs forever without growing the stack
|
||||
(define (loop n) (loop (+ n 1)))
|
||||
|
||||
**Why this matters**: Python's default recursion limit is 1,000 frames. A Scheme that uses the Python stack for Scheme calls inherits this limit. The explicit frame stack removes it. uncommonlisp can recurse 50,000 deep without difficulty, limited only by available memory.
|
||||
**Why this matters**: Python's default recursion limit is 1,000 frames. A Scheme that uses the Python stack for Scheme calls inherits this limit. The explicit frame stack removes it. Lumbda can recurse 50,000 deep without difficulty, limited only by available memory.
|
||||
|
||||
|
||||
4. Continuations: Feedback as a Data Structure
|
||||
|
|
@ -236,7 +236,7 @@ When a continuation is invoked:
|
|||
4.1 Generators from Continuations
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
A generator in uncommonlisp uses ``call/cc`` to yield values & resume later:
|
||||
A generator in Lumbda uses ``call/cc`` to yield values & resume later:
|
||||
|
||||
::
|
||||
|
||||
|
|
@ -378,7 +378,7 @@ Each target's script lives under ``tests/`` and uses the six-layer safety envelo
|
|||
mergesort (200 elements) 428.6 39.1 0.3 11.0x
|
||||
============================== ========= ======= ======= =============
|
||||
|
||||
**BC Speedup** = interpreter time / bytecode time. This measures the gain from compilation within uncommonlisp itself.
|
||||
**BC Speedup** = interpreter time / bytecode time. This measures the gain from compilation within Lumbda itself.
|
||||
|
||||
6.2 Analysis
|
||||
^^^^^^^^^^^^^
|
||||
|
|
@ -387,9 +387,9 @@ The bytecode compiler delivers **7--12x speedups** on recursive & iterative work
|
|||
|
||||
Hash table operations show a smaller speedup (1.6x) because the bottleneck sits in Python's dictionary operations, not in Scheme evaluation overhead.
|
||||
|
||||
CPython remains 50--150x faster than the bytecode VM on most benchmarks. This is expected: CPython compiles to native bytecode with a C runtime, while uncommonlisp's bytecode VM is itself written in Python. The comparison establishes that uncommonlisp pays a known, bounded overhead for running a complete Scheme (with full ``call/cc``, exact rationals, & hygienic macros) inside a host language.
|
||||
CPython remains 50--150x faster than the bytecode VM on most benchmarks. This is expected: CPython compiles to native bytecode with a C runtime, while Lumbda's bytecode VM is itself written in Python. The comparison establishes that Lumbda pays a known, bounded overhead for running a complete Scheme (with full ``call/cc``, exact rationals, & hygienic macros) inside a host language.
|
||||
|
||||
The important comparison is not uncommonlisp vs CPython (different languages), but uncommonlisp interpreter vs uncommonlisp bytecode (same language, same semantics, different execution strategy). The bytecode compiler proves that feedback-based architecture does not preclude efficient execution.
|
||||
The important comparison is not Lumbda vs CPython (different languages), but Lumbda interpreter vs Lumbda bytecode (same language, same semantics, different execution strategy). The bytecode compiler proves that feedback-based architecture does not preclude efficient execution.
|
||||
|
||||
6.3 What the Benchmarks Test
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
@ -444,7 +444,7 @@ C wins every workload on this hardware. Its bytecode compiler + explicit frame s
|
|||
7. Portal: Feedback Across Time
|
||||
----------------------------------------
|
||||
|
||||
A continuation is feedback within a process. A portal is feedback across processes. Same primitive, different scope: capture machine state, serialize it, reload it elsewhere, resume. uncommonlisp ships three portal formats with different tradeoffs & constituencies.
|
||||
A continuation is feedback within a process. A portal is feedback across processes. Same primitive, different scope: capture machine state, serialize it, reload it elsewhere, resume. Lumbda ships three portal formats with different tradeoffs & constituencies.
|
||||
|
||||
.. table::
|
||||
:widths: 22 22 14 14 14 14
|
||||
|
|
@ -466,7 +466,7 @@ The most boring format is the most portable. An S-expression portal is a sequenc
|
|||
|
||||
::
|
||||
|
||||
;; uncommonlisp portable state
|
||||
;; Lumbda portable state
|
||||
(define my-int 42)
|
||||
(define my-list '(1 2 3 4 5 6 7 8 9 10))
|
||||
(define my-str "hello world")
|
||||
|
|
@ -610,7 +610,7 @@ Machine A starts the computation. Every 10,000 iterations, it writes a checkpoin
|
|||
8. The EML Universality Proof
|
||||
-------------------------------
|
||||
|
||||
uncommonlisp ships with a mathematical proof that a single operator generates all elementary functions: ``eml(x, y) = exp(x) - ln(y)``.
|
||||
Lumbda ships with a mathematical proof that a single operator generates all elementary functions: ``eml(x, y) = exp(x) - ln(y)``.
|
||||
|
||||
Reference: "All elementary functions from a single operator" (arXiv:2603.21852v2).
|
||||
|
||||
|
|
@ -680,9 +680,9 @@ The proof is verified at three levels, with dramatically different friction:
|
|||
============================== ======== ========================= =================================
|
||||
Approach Time Guarantee Friction
|
||||
============================== ======== ========================= =================================
|
||||
Python (numerical) 0.04s 1e-10 tolerance Low: evaluate & compare
|
||||
uncommonlisp (numerical) 59s 1e-10 tolerance High: O(N²) brute-force search
|
||||
Lean 4 (formal proof) 1.5s kernel-verified certainty Medium: 5 rewrites, type-check
|
||||
Python (numerical) 0.04s 1e-10 tolerance Low: evaluate & compare
|
||||
Lumbda (numerical) 59s 1e-10 tolerance High: O(N²) brute-force search
|
||||
Lean 4 (formal proof) 1.5s kernel-verified certainty Medium: 5 rewrites, type-check
|
||||
============================== ======== ========================= =================================
|
||||
|
||||
**The formal proof is 40x faster than the brute-force search & provides mathematical certainty instead of floating-point tolerance.** This is MOAD-0001 (the sedimentary defect) at the proof methodology layer: O(N²) search friction where O(1) algebraic reasoning suffices.
|
||||
|
|
@ -693,7 +693,7 @@ The numerical approaches enumerate all pairwise EML compositions at each depth,
|
|||
|
||||
1. **Numerical verification** (``proof/eml_proof.py``): Python script using ``cmath`` at high precision. Verifies every derivation step with tolerance ``1e-10``. Includes brute-force tree search at depth ≤ 4 confirming that eml compositions reach the expected targets.
|
||||
|
||||
2. **Self-hosted verification** (``proof/eml_proof.lsp``): The same proof runs in uncommonlisp's bytecode VM (``python3 uncommonlisp.py --fast proof/eml_proof.lsp``). The language verifies its own mathematical foundations.
|
||||
2. **Self-hosted verification** (``proof/eml_proof.lsp``): The same proof runs in Lumbda's bytecode VM (``python3 uncommonlisp.py --fast proof/eml_proof.lsp``). The language verifies its own mathematical foundations.
|
||||
|
||||
3. **Formal proof** (``proof/lean/EmlProof/Basic.lean``): Lean 4 proof with zero ``sorry``. Five theorems:
|
||||
|
||||
|
|
@ -713,7 +713,7 @@ The Lean proof operates over abstract ``exp`` & ``ln`` functions with the axioms
|
|||
9. Language Coverage
|
||||
---------------------
|
||||
|
||||
uncommonlisp implements a near-complete R7RS-small Scheme:
|
||||
Lumbda implements a near-complete R7RS-small Scheme:
|
||||
|
||||
**Special forms** (32): ``define``, ``set!``, ``lambda``, ``λ``, ``if``, ``cond``, ``case``, ``and``, ``or``, ``when``, ``unless``, ``begin``, ``let``, ``let*``, ``letrec``, ``letrec*``, named-let, ``do``, ``quasiquote``, ``define-macro``, ``define-syntax``, ``syntax-rules``, ``let-syntax``, ``letrec-syntax``, ``apply``, ``eval``, ``values``, ``call/cc``, ``dynamic-wind``, ``guard``, ``parameterize``, ``load``, ``error``, ``module``, ``import``, ``define-record-type``.
|
||||
|
||||
|
|
@ -729,7 +729,7 @@ uncommonlisp implements a near-complete R7RS-small Scheme:
|
|||
10. Relationship to Companion Papers
|
||||
--------------------------------------
|
||||
|
||||
uncommonlisp forms one piece of a larger permacomputer machine learning stack:
|
||||
Lumbda forms one piece of a larger permacomputer machine learning stack:
|
||||
|
||||
.. table::
|
||||
:widths: 20 35 45
|
||||
|
|
@ -743,7 +743,7 @@ uncommonlisp forms one piece of a larger permacomputer machine learning stack:
|
|||
Infra Machine Learning Agent Self-Sandbox Algorithm Agents provision their own compute
|
||||
============= ================================================ ================================================
|
||||
|
||||
uncommonlisp provides the runtime layer: a language that can checkpoint its own execution, migrate between machines, & resume from serialized state. The portal system enables distributed computation across permacomputer nodes. Categorization & feedback activities could run inside uncommonlisp's VM, with ``call/cc`` providing the state machine transitions & portal providing persistence.
|
||||
Lumbda provides the runtime layer: a language that can checkpoint its own execution, migrate between machines, & resume from serialized state. The portal system enables distributed computation across permacomputer nodes. Categorization & feedback activities could run inside Lumbda's VM, with ``call/cc`` providing the state machine transitions & portal providing persistence.
|
||||
|
||||
|
||||
11. Three Implementations, One Language
|
||||
|
|
@ -763,7 +763,7 @@ uncommonlisp provides the runtime layer: a language that can checkpoint its own
|
|||
|
||||
*Asm implementation: the whole language in one register file and thirteen Linux syscalls. No libc, no bytecode, no JIT. Heap is a bump pointer (r15) with mmap-grown chunks; env is a linked list of pairs rooted at r14; values are tagged in the low 3 bits. Every Scheme feature — continuations-free tree-walker, full TCO via jmp, portal-save / portal-resume, TCP sockets, 91 builtins — fits in 22 KB stripped.*
|
||||
|
||||
uncommonlisp implements R7RS Scheme in three implementations sharing the same ``.lsp`` test files. The language is Scheme (a dialect of Lisp, designed 1975). The project name plays on Common Lisp — this is decidedly uncommon.
|
||||
Lumbda implements R7RS Scheme in three implementations sharing the same ``.lsp`` test files. The language is Scheme (a dialect of Lisp, designed 1975). The project name plays on Common Lisp — this is decidedly uncommon.
|
||||
|
||||
.. table::
|
||||
:widths: 24 8 10 10 11 10 9
|
||||
|
|
@ -1059,7 +1059,7 @@ This is the permacomputer obligation: infrastructure that renews itself. Code th
|
|||
- **Copying GC in asm**: ``heap-snapshot`` is an escape hatch. A mark-and-copy collector would remove the sharp edge for general programs without forcing the programmer to reason about lifetimes.
|
||||
- **Concurrent accept loop (asm)**: Currently single-threaded. A pre-forked worker model or ``SO_REUSEPORT`` pool would multiply throughput without changing the Scheme code.
|
||||
- **Complex number arithmetic**: Extending the numeric tower for the full EML derivation chain
|
||||
- **Activity VM**: Running categorization-and-feedback YAML activities directly in uncommonlisp
|
||||
- **Activity VM**: Running categorization-and-feedback YAML activities directly in Lumbda
|
||||
|
||||
|
||||
14. The Defect in the Model
|
||||
|
|
@ -1069,7 +1069,7 @@ This paper is evidence of a problem that extends beyond any single codebase.
|
|||
|
||||
On April 4, 2026, russell@unturf published `"Stress on Our Shared Heart" <https://undefect.com/public/stress-on-our-shared-heart/>`_ — a systematic analysis of 1,264 MOAD defects across 60+ ecosystems, 18 programming languages, with 919 patches written. The central finding: O(N²) sedimentary defects compound across architectural layers, creating invisible performance taxation on every downstream consumer. A single bottleneck multiplies against every other bottleneck in the dependency chain.
|
||||
|
||||
On April 13--14, 2026 — nine days later — the machine learning agent that built uncommonlisp wrote MOAD-0001 into fresh code. Twice.
|
||||
On April 13--14, 2026 — nine days later — the machine learning agent that built Lumbda wrote MOAD-0001 into fresh code. Twice.
|
||||
|
||||
``intern_symbol`` in the assembly implementation: a linear scan through all interned symbols. O(N) per lookup. The exact pattern described in "Stress on Our Shared Heart." The exact pattern the agent was explicitly instructed to avoid. The agent had the full MOAD taxonomy in its context window. It had ``BLACKOPS.md`` defining all five MOADs. It had the undefect.com mission statement. And it still wrote ``jmp .isym_search`` instead of a hash table.
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue