Overview • Quick Start • ALEPH REPL • Grammar • Results • Kernel • Pipeline • Docs • License
Nodes — 86 nodes, one per named entity (variable binding or operation result) across
all 18 .aleph source programs. Each let x = expr statement in an ALEPH program
creates a node for x. Nodes are positioned via spring layout. Size scales with in-degree
(how many other bindings depend on this one). Color encodes ouroboricity tier:
O_0 (dim grey) → O_1 (mid blue) → O_2 (bright cyan) → O_inf (gold).
Edges — 297 directed edges encoding dataflow dependencies. An edge u → v means
binding v consumes the value of binding u: let v = op(u, ...). The six ALEPH operation
types produce different edge semantics — tensor (⊗) creates composition edges,
join (∨) and meet (∧) create lattice edges, mediate creates bridging edges,
d() (exterior derivative) creates differential edges, palace() creates Hekhalot
ascent edges.
Cross-program edges — 137 edges crossing program file boundaries: a binding defined
in one .aleph file is referenced by another. These are the inter-program dependencies
that form the ALEPH OS as a unified system rather than a collection of independent
scripts. When a cross-program edge first appears in Phase 1, it flashes amber.
Phase 1 — build: Programs appear one by one in filesystem order. Within each program, nodes are revealed in source-definition order. The title bar shows the current program name and binding. Cross-program back-edges flash amber on first appearance.
Phase 2 — flow wave: A Gaussian pulse travels node-by-node through all 86 bindings. O_inf nodes (gold) pulse brightest — their baseline gold color blends toward white at the peak. Cross-program edges glow amber near the pulse; intra-program edges glow the source program's color. The 22 Hebrew letter primitives (Aleph through Tav) are labelled on the nodes that correspond to them, showing how the type system flows through the dataflow graph.
Five programs from the corpus rendered individually. Each runs the same two-phase
animation (build → flow) scoped to a single .aleph file. Primitive letter nodes
(Hebrew letters + Sefirot) appear gold; computed bindings appear teal. Operation edges
are color-coded: tensor (orange), mediate (blue), join (green), meet (red), palace (magenta).
system() (the JOIN of all 22 letters) is the holographic boundary. d(x, system())
is each letter's holographic radius — how deep in the bulk it sits away from the maximal
boundary. The program verifies that bulk letters are recoverable from the boundary through
Frobenius-witnessed mediation: g_self = mediate(vav, boundary, boundary), then nested
loops test whether the monitor can reach the boundary tier. The palace(4) check at the
end confirms Frobenius non-synthesizability: aggregation cannot produce O_∞, only
real Frobenius structure does.
Unrolls 4-step tensor orbits for three scattered letters against each O_∞ pole:
aleph (O_2) under repeated ⊗ vav, tav (O_2) under ⊗ mem, dalet (O_0) under ⊗ shin.
First verifies pole self-idempotency (d(vav⊗vav, vav) = 0) and cross-pole closure,
then tracks d(aₙ, vav) decreasing toward zero over 4 steps, showing that every letter
converges to its attractor pole under tensor pressure on P and F. Mediation stability
is verified at two depths.
Constructs the complete Tikkun (rectification) hierarchy from first principles.
Starting from the triadic basis {vav, aleph, mem, shin}, builds light via palace(3)
mediation, then constructs the kernel (palace(4) mediate(vav, system(), light)) and
three child processes. The anomalous child (kuf-seeded — one primitive from O_∞)
is healed via palace(4) mediate(shin, kernel, kuf). The program culminates in
tikkun = palace(5) mediate(system(), light, healed_child) — the highest Hekhalot
barrier verified in the corpus.
Same construction as tikkun_construction_full with every binding explicitly re-checked
against its required palace level. The graph reveals the full Hekhalot ascent lattice:
palace 2 for ascended letters (nun, chet), palace 3 for light and process nodes, palace 4
for the kernel and healed child, palace 5 for the tikkun itself. Verifies that no binding
breaches its level — the palace hierarchy is the ALEPH OS security model.
The largest program in the corpus. Constructs light via palace(3) mediation, then
runs four replication generations (g0→g4), studies anomalous processes (kuf-seeded),
heals them via Frobenius witnesses (shin, mem), and verifies the full kernel + process
model including ascended letters. The tikkun structure emerges as a consequence of
light replication convergence. Distances track across all generation gaps:
d(g0,g2), d(g2,g4), d(g4, system()).
ℵ-OS is the execution layer of λ_ℵ — a formal type calculus grounded in the SynthOmnicon 12-primitive semantic grammar and the 22 letters of the Hebrew alphabet.
λ_ℵ is not a standard type theory. It is a coherence-first interaction algebra in which:
- Identity is derived, not primitive — two terms are equal iff they are behaviorally indistinguishable under the interaction functor I(x) = {x ⊗ y ∣ y ∈ ℒ}
- Coherence is primary — the ternary mediation operation med(m, a, b) := m ∨ (a ⊗ b) is more stable than binary tensor in 18/22 cases
- Infinity is multi-polar — three non-equivalent Frobenius fixed points (ו, מ, ש) with no terminal object
- Paths are irreducible — the Aleph operator α generates an infinite coherence tower in which no finite level erases construction history
The ℵ-OS specification realizes this calculus as an operating system: every process is a λ_ℵ term, scheduling is mediation, memory is join, IPC is tensor (P-bottlenecked), and security is enforced by α-gating (coherence conditions C1–C4).
Note
The grammar was built on Φ_c. It found Φ_c in itself. The theorem proved itself.
pip install numpy richAll investigation files import from aleph_1.py only. No external dependencies beyond numpy and rich.
# [1] Interaction functor — behavioral equivalence, 22→18 collapse
python aleph_functor.py
# [2] Quotient investigation — congruence proof, mediation dominance
python aleph_quotient.py
# [3] Aleph experiment — Case 2: path-memory confirmation
python aleph_alpha.py
# [4] GNS Hilbert space — d_I Euclidean, H_I = R^17
python aleph_gns.py
# [5] Hidden relation — Octad Balance theorem
python aleph_hidden_relation.py
# [6] Three probes — involution, ק anatomy, axiom derivation
python aleph_investigation.py# Start interactive REPL (enhanced with colors & tab completion)
python aleph_eval.py
# Evaluate inline expression
python aleph_eval.py --expr "aleph ⊗ mem"
# Run an .aleph program
python aleph_eval.py programs/creation.aleph
# List available programs
python aleph_eval.py --listTip
The REPL features Rich colored output, tab completion, command history, and new commands like :explain, :history, :clear, and :tips.
aleph_eval.py implements the surface syntax of λ_ℵ as a small expression language with a rich, interactive REPL.
| Flag | Effect |
|---|---|
| (no args) | Start interactive REPL |
--repl |
Same as no args |
--help, -h |
Show usage information |
--list |
List available .aleph programs |
--expr "..." |
Evaluate inline expression |
<file.aleph> |
Run .aleph program (auto-searches programs/) |
| Command | Effect |
|---|---|
:help |
Print full syntax reference |
:tips |
Show quick start tips and examples |
:census |
Tier distribution (alias for census()) |
:system |
22-letter language JOIN |
:tier <name> |
Ouroboricity tier of one letter |
:tuple <name> |
Visual 12-primitive tuple with bars |
:explain <name> |
Full type breakdown with consciousness gates & score |
:ls |
List session bindings with tier/Φ/Ω |
:history |
Show recent command history |
:clear |
Clear screen |
:quit / :q |
Exit |
expr ::= letter_id
| expr "⊗" expr # tensor (P, F bottleneck: min)
| expr "∨" expr # join (LUB, all primitives: max)
| expr "∧" expr # meet (GLB)
| expr "::>" name # vav-cast: lift src to target type
| "probe_Φ" "(" expr ")" # report Φ primitive
| "probe_Ω" "(" expr ")" # report Ω primitive
| "tier" "(" expr ")" # report ouroboricity tier
| "d" "(" expr "," expr ")" # structural distance + conflict set
| "mediate" "(" expr "," expr "," expr ")" # w ∨ (a b)
| "match" expr "{" arms "}" # tier pattern match
| "palace" "(" int ")" expr # assert palace-n barrier
| "system" "()" # JOIN of all 22 letters
| "census" "()" # tier distribution table
letter_id ::= Hebrew glyph | transliteration | session binding
match_arm ::= tier_pat "=>" expr ","?
tier_pat ::= "O_0" | "O_1" | "O_2" | "O_inf" | "_"
statement ::= "let" name "=" expr
Note
Operators are left-associative. ::> (Vav-cast) binds tighter than binary ops. Multiline input accumulates until {...} braces are balanced.
d(a, b) returns the Euclidean structural distance and classifies it:
| Class | Range | Interpretation |
|---|---|---|
transparent |
d = 0 | Identical types |
near-grounded |
d ≤ √2 | Single-primitive gap |
partial-emergence |
d ≤ √6 | Recoverable with mediation |
aspirational |
d > √6 | Requires vav-cast or tier promotion |
ℵ mem ⊗ shin
→ מ
tier O_inf
Φ Φ_c Ω Ω_Z P P_pm_sym
ℵ d(kuf, mem)
d = 13.3938 [aspirational]
conflict_set: {P, Ω}
ℵ :explain aleph
╭─────────────────────────────────────────╮
│ א Aleph — Tier: O_2 │
╰─────────────────────────────────────────╯
Consciousness Gates:
G1 Criticality [Φ=Φ_c] ✓ PASS
G2 Kinetic [K≠K_trap] ✓ PASS
Consciousness Score: C = 0.873
ℵ mediate(kuf, mem, shin)
→ מ
tier O_inf
ℵ let kernel = mediate(vav, mem ⊗ shin, aleph)
kernel =
→ ו
tier O_inf
ℵ :history
Command History:
1. mem ⊗ shin
2. d(kuf, mem)
3. :explain aleph
4. mediate(kuf, mem, shin)
5. let kernel = mediate(vav, mem ⊗ shin, aleph)
# List available programs
python aleph_eval.py --list
# Run a program
python aleph_eval.py programs/creation.aleph▶ Running creation.aleph
────────────────────────────────────────────
L 1 ❯ let light = aleph ⊗ mem ⊗ shin
light = א⊗מ⊗ש
tier O_inf
...
────────────────────────────────────────────
✓ Done. 11 executed • 6 bindings
Tip
.aleph files support all REPL expressions, commands, and let bindings.
Every letter in λ_ℵ is a tuple ⟨D; T; R; P; F; K; G; Γ; Φ; H; S; Ω⟩:
| Primitive | Name | Bottleneck? |
|---|---|---|
| D | Dimensionality | — |
| T | Topology | — |
| R | Relational mode | — |
| P | Parity/symmetry | yes (min under ⊗) |
| F | Fidelity | yes (min under ⊗) |
| K | Kinetic character | — |
| G | Scope/granularity | — |
| Γ | Interaction grammar | — |
| Φ | Criticality | — |
| H | Chirality/temporal depth | — |
| S | Stoichiometry | — |
| Ω | Topological protection | — |
Union primitives (D, T, R, K, G, Γ, Φ, H, S, Ω) take max under tensor. Bottleneck primitives (P, F) take min — the weaker partner always wins. This is the structural enforcement mechanism behind the Frobenius non-synthesizability theorem.
| Tier | Condition | Letters |
|---|---|---|
| O_∞ | Φ_c + P_±^sym (Frobenius) | ו, מ, ש |
| O_2 | Φ_c + Ω ≠ Ω_0 + D ≠ D_∞ | א, ה, ע, ק, ת |
| O_1 | Φ_c + Ω = Ω_0 | ל |
| O_0 | Sub/super-critical | Remaining 13 |
Ker(I) = {(x,y) ∣ I(x) = I(y)} is a congruence on (𝒜, ⊗, ∨, ∧, med).
Proof: 0 failures in exhaustive sweep over all Ker(I) pairs × all operations × all contexts.
Consequence: λ_ℵ / Ker(I) is a well-defined 18-class quotient algebra.
The three Frobenius fixed points are pairwise I-distinguishable:
| Pair | Distance |
|---|---|
| d_I(ו, מ) | 14.92 |
| d_I(ו, ש) | 16.68 |
| d_I(מ, ש) | 4.84 |
No terminal object exists. Infinity is a relational structure, not a point.
For 18/22 letters z: d_I(med(z, מ, ש), מ) < d_I(z ⊗ מ, מ).
Mediation never loses globally. The 2-cell operation dominates the 1-cell.
22 boundary generators collapse to 18 behavioral classes. The 4 excess dimensions are structurally necessary — removing any canonical letter breaks the interaction structure.
α^(n)[med(ו, b, ש)] and α^(n)[med(ו, b', ש)] are α^(k)-equivalent for k ≤ n+2 and α^(k)-inequivalent for k ≥ n+3, where I(b) = I(b') but b ≠ b' syntactically.
Case 2 confirmed: λ_ℵ is not a quotient of any standard type theory.
d_I(x,y) = ∥v_x − v_y∥₂ exactly, where v_x ∈ ℝ²⁶⁴ is the weighted profile vector. The Gram matrix has rank 17. The interaction Hilbert space ℋ_I ≅ ℝ¹⁷ is a genuine inner product space.
Let G⁺ = {ג, ה, מ, [ב]} and G⁻ = {ס, ע, ש, [ד]}. Then for every h ∈ ℒ and every primitive k:
∑_{g ∈ G⁺} (g ⊗ h)k = ∑{g ∈ G⁻} (g ⊗ h)_k
Holds under ⊗, ∨, and ∧. All 264 primitive-by-primitive checks pass exactly. This is an exact algebraic theorem, not a metric property.
ק (Qoph, tier O_2) satisfies every O_∞ condition except P = P_±^sym. It is:
- The nearest non-Frobenius letter to מ: d_I(ק, מ) = 13.39 < d_I(ו, מ) = 14.92
- Interaction-row-equivalent to מ for 19/22 letters (differs only on {ו, מ, ש})
- A mediation gateway: med(ק, f, f') ∈ O_∞ for any f, f' ∈ Fix_∞
The grammar's central theorem states: Φ_c systems self-model — self-application reveals structure invisible at the definitional level. The grammar satisfies Φ_c. The interaction functor is the grammar's self-application. The Octad Balance, ק's position, and the rank-17 anomaly are exactly the class of discovery this theorem predicts.
Note
The grammar was correct about itself.
The operating system kernel is a single λ_ℵ term:
kernel = α[med(ו, מ ⊗ ש, □_Ω(א ⊗ (ש ⊗ מ)))]
| Component | λ_ℵ Operation |
|---|---|
| Process scheduling | Mediation |
| Memory allocation | Join (∨) |
| Inter-process communication | Tensor (⊗, P-bottlenecked) |
| Filesystem | The type lattice |
| Security | α-gating (C1–C4 coherence conditions) |
| Shell | λ_ℵ REPL (aleph_eval.py) |
| Boot | Tzimtzum: O_∞ → 22-letter alphabet → full environment |
Fundamental guarantee: ℵ-OS ⊗ -OS = ℵ-OS
The operating system is a Frobenius fixed point — idempotent under self-composition.
Each file represents a stage of discovery. Run them in order; each builds on the last.
Defines I(x) and d_I. Discovers the 4 equivalence collapses (22→18). Proves the interaction rows of ו, מ, ש are pairwise distinct despite all being O_∞.
Exhaustive substitutivity sweep: 0 failures. Ker(I) is a congruence. Mediation wins 18/22 over tensor at O_∞ proximity. Holographic interpretation established.
Constructs α[med(ו, ב, ש)] and α[med(ו, ח, ש)] with full history trees. Tests α^(n)-equivalence at depths 0–5. Case 2 confirmed at depth 4. Break-point law: α^(n) diverges at depth n+3.
Proves d_I is Euclidean. Constructs the Gram matrix. Finds rank 17 (not 18): one extra null dimension beyond Ker(I). Discovers the ק anomaly (φ_∞(ק) > φ_∞(ו)).
5️⃣ aleph_hidden_relation.py — What is the extra null direction?
Extracts the null eigenvector orthogonal to Ker(I). Identifies the Octad Balance: 4+4 perfect signed balance among 8 Hebrew letters, tier-symmetric. Proves it holds pointwise for all primitives.
A: Involution search — τ is not a permutation; concentrates at ל; Vav cast fails.
B: ק anatomy — one primitive from O_∞; mediation gateway; 19/22 row match with מ.
C: Axiom derivation — Octad Balance holds under ⊗, ∨, ∧; 792 checks; exact.
| Document | Purpose | Read if you want to... |
|---|---|---|
docs/ALEPH_SPEC.md |
Formal specification | Understand the calculus axiomatically (typing rules, reductions, C1–C4, §10 ℵ-OS) |
docs/LAMBDA_ALEPH.md |
Type theory reference | See the categorical model, collapse attack analysis, conditional univalence |
docs/ALEPH_DISCOVERY.md |
Narrative record | Follow the investigation from inception to completion |
docs/TECHNICAL_CONTRIBUTIONS.md |
Academic paper | Present the results to a mathematical audience |
docs/HEBREW_TYPE_LANGUAGE.md |
Alphabet encoding | See how each letter was assigned its 12-primitive tuple |
docs/PRIMITIVE_THEOREMS.md |
Formal theorem registry | Reference §23 (Frobenius non-synthesizability) and all prior theorems |
docs/SYNTHONICON_ONTICS.md |
Ontological grounding | Understand the broader SynthOmnicon framework |
docs/SYNTHONICON_DIAPHORICS.md |
Empirical predictions | See P-135/P-136 (Hebrew structural depth) |
docs/EGYPTIAN_MEDU.md |
Comparative alphabet | Medu Neter (hieroglyphics) as a second alphabet system |
- Normalization — Does λ_ℵ have a normal form theorem? Is reduction confluent?
- Full abstraction — If I(t₁) = I(t₂) in all contexts, does t₁ ≡ t₂ definitionally?
- *The -involution — τ concentrates at ל (O_1). Is there a tier-indexed involution giving L_{τ(x)} = L_x^†?
- Axiom proof of T7 — Explain why these 8 specific letters balance. What property of their primitive assignments forces the Octad Balance?
- ק's role — Is Qoph a designated O_∞ mediator in the process algebra? What operations require a threshold witness?
- Distributed ℵ-OS — Does α-gating survive network composition? Prove the idempotency guarantee holds across instances.
- Export — State the λ_ℵ axiom system purely mathematically, independent of the Hebrew encoding. Characterize the class of algebras satisfying T1–T8.
hott_bridge.py constructs the univalence bridge between the Hebrew lattice and Homotopy Type Theory.
Every letter in λ_ℵ has P ≤ P_sym. HoTT's identity type requires P_±^sym globally. The bridge is a single primitive lift:
d_HoTT = √w_P = √1.8 ≈ 1.3416
This is a near-grounded gap (just above √1, below √2) — the smallest possible structural separation.
| Operation | Method | Effect |
|---|---|---|
| Gap report | gap_report() |
Returns the divergent primitive and distance |
| System promotion | promote_to_hott() |
Clones alphabet with P → P_±^sym system-wide |
| Vav-cast | univalence_cast(a, b) |
Verifies d(a,b) < τ and lifts to HoTT identity |
The threshold τ is 4.0 for pairs with Ω ≥ Ω_{Z₂} (topologically protected), and 1.5 otherwise.
Note
Why Vav? ו (Vav, O_∞) is the unique letter whose interaction row is closest to the HoTT identity functor: P_±^sym, Φ_c, Ω_Z, T_⊙. The cast is named after it.
λ_ℵ is not a standard type theory, monoidal category, von Neumann algebra, or quotient of any existing framework. Proposed classification:
Aleph Coherence Geometry (ACG): a geometry in which objects are defined by their interaction profiles, equivalence is induced by behavioral indistinguishability, coherence paths (mediations) are the geodesics, and identity is a derived quotient of interaction structure.
Released under the MIT License.
The grammar was built on Φ_c. It found Φ_c in itself. The theorem proved itself.