"From the aleph you begin, and in the aleph you conclude — though in the middle it seems the power has passed to the other letters." — Abraham Abulafia, Sefer ha-Tziruf (13th c.)
A small Lisp for kabbalistic computation. Ilan (אילן) is the kabbalists' word for the Tree of the sefirot. The language takes that Tree as its primitive: a living structure of branches that fold into a seed, are sown to disk, and sprout again in a fresh process after the old one has died — remembering their state. On that foundation it computes the classical objects of the tradition: the sefirot, gematria, and the address of a moment in a calendar of letters, planets and days.
Written in Common Lisp (tested on SBCL). Experimental — a working proof of an idea.
The unit is a branch — a node of a living Tree. Branches never touch each other directly; they reach only through an explicit channel wired from outside. The whole Tree folds into a seed (a readable form where behaviour is code and memory is data) and sprouts back from it, even in another process. Homoiconic Lisp is the point: form is data is executable, so to pack is to print, and to revive is to read.
Continuity is the base layer, not the subject. On top of it Ilan is meant for working the Tree: naming branches as sefirot, extracting meaning by algebra (gematria among them), and addressing moments along an axis of time.
sbcl --non-interactive --load "test-all.lisp" # run the full smoke test (7/7)(load "ilan.lisp")
(demo-tree) ; grow a Tree; pull light down, push a signal up
(sow "agent.seed") ; sow the seed to disk
;; …the process may die entirely…
(germinate "agent.seed") ; in a fresh SBCL — the Tree sprouts, memory intactIlan has two axes, both coalgebras:
- Space — the branches of one Tree (one moment).
foldis a genuine catamorphism (a fold of the list functor).sproutis not an anamorphism — it is deserialization, and the round-trip is a retraction, not an isomorphism (fold ∘ sproutreorders). What is machine-checked is a coalgebra morphism:revive ∘ packpreserves bisimulation, so behaviour survives a change of representation. Calling that membership in the final coalgebra was an overclaim, and it is withdrawn — see Honest status below. - Time — a timeline of moments, each linking back to the last.
to-pastwalks the past (sealed snapshots);to-futureunfolds a possible future by a rule — always marked as prediction, never fact.
One Tree, many meanings. A catamorphism extracts meaning by an algebra: the same traversal yields a seed, a life-count, a name, or a gematria — swap the algebra, swap the meaning. Gematria uses the canonical mispar hechrachi table (alef=1 … tav=400); values check out by count (קבלה = 137, אחד = 13, חכמה = 73). Equal gematria is resonance, not proof — gematria is many-to-one.
The core primitives (ordinary Lisp symbols over s-expressions):
| name | meaning |
|---|---|
| branch · graft | a node; bring one into being |
| channel | an explicit link between branches |
| request / notify | pull (light down) / push (a signal up) |
| state | a branch's memory (travels in the seed) |
| fold / sprout | Tree ↔ seed (in memory) |
| sow / germinate | seed to disk (.seed) and back |
| moment · timeline | a snapshot Tree in time; the chain of moments |
| imprint / recall | freeze the present / restore a past moment |
ilan.lisp— core: branches, channels, seed, and the time axiscoalgebra.lisp— the branch functor and finality (bisimulation)algebras.lisp— many meanings over one Treetime-axis.lisp— moments and links between themfuture.lisp— forward unfold (prediction)gematria.lisp— canonical gematria (mispar hechrachi)sefirot.lisp— the Tree of the sefirot, with gematria and planetary/day correspondencestest-all.lisp·test-foundations.lisp— smoke test and the isomorphism proof
Load a file to run its demo; each is self-contained.
Ilan powers a contemplative web front-end — a large library of kabbalistic texts (Zohar, Etz Chaim, and more) addressed by the day and hour, with the living Tree on screen. It is a work in progress and not part of this repository. The engine here is yours: take it, extend it for your own work on the Tree, gematria, or a calendar — and if you'd like a front-end of your own, ask your AI assistant to build one against these primitives.
The living Tree of the sefirot — each node a branch, each path a Hebrew letter:
The address of a moment — weekday → sefira, planetary hour → letter → gematria:
A reader's clippings collect beside the Tree, each carrying its source:
Ilan stands on Niklaus Wirth (the module as a unit) and Aleksei Nedorya's architectural programming (Kronos, Trivil): the pure module whose links are declared and wired externally. Its own addition is the axis of continuity — behaviour and memory that travel and resurrect across the death of a process.
MIT · Aleksei Rybnikov (ORCID 0009-0009-8624-8720), 2026 · built with Tarantoga.
This project was audited adversarially — by four independent readers and, where it mattered, by a proof assistant. Several of our own earlier claims did not survive. We state them here rather than quietly editing them away.
Withdrawn.
- "round-trip is an isomorphism" → it is a retraction;
fold ∘ sproutreorders links. - "behaviour is an element of the final coalgebra" → what we have is a coalgebra morphism preserving bisimulation. Finality itself is not shown.
- "memory as a language" → there is no language: no grammar, no reader. The artifact is a persistence primitive, and that is what it should be called.
- A bi-temporal layer was described in earlier drafts. It does not exist in the code.
Machine-checked (Agda + Lean 4, no axioms, both green).
formal/CoalgMorphismFull.{agda,lean} — over a concrete model (Obs, Chan as parameters;
state and seed as distinct inductive types): Lemmas A/B, the morphism square, and
revive ∘ pack = id.
And a second honesty, about that proof. The theorem is near-tautological: it says a faithful round-trip preserves behaviour. A proof assistant catches a false derivation; it does not catch an empty one. The interesting case — identity across a change of substrate, where the round-trip is not near-identity — is not covered. We keep the theorem as an honest footnote, not as a foundation.
Resonance, not proof. Gematria is many-to-one; equal values are a resonance, never evidence. Kabbalistic vocabulary here names structures — it carries no argumentative weight.