rei-lang 0.3.0 → 0.4.0

package/README.md

@@ -1,186 +1,257 @@
-# Rei (0₀式/れいしき) — D-FUMT Computational Language
-
-[![npm version](https://img.shields.io/npm/v/rei-lang)](https://www.npmjs.com/package/rei-lang)
-[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](./LICENSE)
-[![Tests](https://img.shields.io/badge/tests-226%2F226-brightgreen)]()
-
-**Rei** is a programming language based on D-FUMT (Dimensional Fujimoto Universal Mathematical Theory) — a paradigm where every computation flows through the center-periphery pattern `𝕄{center; periphery}`.
-
-v0.3 introduces the **Space-Layer-Diffusion** computation model and **Category C** — 25 consciousness axioms that give values self-awareness, tendency, resonance, and multi-perspective computation.
-
-## Install
-
-```bash
-npm install rei-lang
-```
-
-## Quick Start
-
-```typescript
-import { rei } from 'rei-lang';
-
-// Multi-dimensional computation — center-periphery pattern
-rei('𝕄{5; 1, 2, 3, 4} |> compute');        // 7.5
-
-// σ: Self-reference — every value knows itself (C1)
-rei('42 |> sigma');                          // { field, will, memory, ... }
-
-// Project anything into 𝕄 (N1)
-rei('[1, 5, 3] |> project("max") |> compute');  // 5 + (1+3)/2 = 7
-
-// Multi-mode consensus (A3)
-rei('𝕄{5; 1, 2, 3, 4} |> consensus');       // median, mean, agreement
-```
-
-## CLI
-
-```bash
-# REPL
-npx rei
-
-# Evaluate expression
-npx rei -e '𝕄{5; 1, 2, 3} |> compute'
-
-# Execute file
-npx rei script.rei
-```
-
-## v0.3 — Category C: 25 Consciousness Axioms
-
-Every value in Rei has σ (self-reference), τ (tendency), and participates in an interconnected computation field inspired by Buddhist philosophy — particularly *Indra's Net* (因陀羅網) where every jewel reflects all others.
-
-### Axiom Groups
-
-| Group | Axioms | Philosophy | Commands |
-|-------|--------|-----------|----------|
-| **C** Consciousness | C1-C5 | σ全値型, τ傾向性, 応答, 覚醒, 共鳴 | `sigma`, `awareness`, `resonate` |
-| **N** Non-Numerical | N1-N5 | 射影, 複数射影, 型変換, 合成, 完全性 | `project`, `project_as`, `encode` |
-| **M** Meta-Math | M1-M5 | 計算多元性, 等価, 合成, 導出, 空間 | `compute :mode`, `derive_mode`, `mode_space` |
-| **U** Universal | U1-U5 | 構造還元, 変換保存, 再帰, 架橋, 完全性 | `project_all`, `transform`, `bridge` |
-| **A** Alternative | A1-A5 | 解の多元性, 変換, 合意, 評価, 完全性 | `compute_all`, `consensus`, `best`, `rank` |
-
-### Examples
-
-```typescript
-import { rei } from 'rei-lang';
-
-// ── C1: σ — Self-reference for all types ──
-rei('42 |> sigma');                    // SigmaResult with field, will, memory
-rei('"hello" |> sigma');               // String σ
-rei('𝕄{5; 1, 2, 3} |> sigma');        // MDim σ
-
-// ── C2: τ — Tendency tracking through pipes ──
-rei('100 |> sqrt |> sqrt |> sigma');   // will.tendency = "contract"
-
-// ── C4: Awakening — Values gain awareness through computation ──
-rei('42 |> awareness');                     // Low (< 0.5)
-rei('𝕄{5; 1,2,3,4,5,6,7,8} |> abs |> negate |> abs |> awakened');  // true
-
-// ── C5: Resonance — Non-local connection between values ──
-rei('𝕄{5; 1, 2, 3} |> resonate(𝕄{5; 1, 2, 3})');   // strength > 0.8
-rei('𝕄{5; 4, 6, 3} |> resonance_map');                // All-pairs resonance
-
-// ── N1-N3: Projection — Anything becomes 𝕄 ──
-rei('[1, 5, 3] |> project("max")');                    // 𝕄{5; 1, 3}
-rei('𝕄{5; 1, 2, 3} |> project_as("graph")');          // GraphProjection
-rei('𝕄{5; 1, 2, 3} |> project_as("tree")');           // TreeProjection
-
-// ── M1: Multiple computation modes ──
-rei('𝕄{5; 1, 2, 3, 4} |> compute :weighted');     // 7.5
-rei('𝕄{5; 1, 2, 3, 4} |> compute :geometric');    // geometric mean
-rei('𝕄{5; 1, 2, 3, 4} |> compute :entropy');      // information entropy
-
-// ── M4: Mode derivation — Create new modes from existing ──
-rei('𝕄{5; 1, 2, 3, 4} |> derive_mode("weighted", 0.7, "geometric", 0.3)');
-
-// ── U3: Hierarchical recursion — 𝕄 within 𝕄 ──
-rei('𝕄{5; 1, 2, 3} |> nest(1) |> depth');          // 1
-
-// ── U4: Domain bridging — Structure transfer ──
-rei('𝕄{5; 1, 2, 3} |> bridge(𝕄{10; 2, 4, 6})');   // scaleFactor: 2
-
-// ── U5: Completeness — Encode/Decode any value ──
-rei('[1, 2, 3] |> encode');             // 𝕄{1; 2, 3}
-rei('𝕄{5; 1, 2, 3} |> decode("array")'); // [5, 1, 2, 3]
-rei('"hi" |> encode');                  // 𝕄{104; 105}
-
-// ── A1-A3: Multiple solutions & consensus ──
-rei('𝕄{5; 1, 2, 3, 4} |> compute_all');   // 8 solutions (all modes)
-rei('𝕄{5; 1, 2, 3, 4} |> consensus');     // { median, mean, agreement }
-
-// ── A4: Solution evaluation ──
-rei('𝕄{5; 1, 2, 3, 4} |> best("max")');   // Highest-value solution
-rei('𝕄{5; 1, 2, 3, 4} |> rank');          // All solutions ranked
-
-// ── Space-Layer-Diffusion ──
-rei('let s = space { layer 0: 𝕄{5; 1, 2, 3} }; s |> sigma');
-```
-
-## 8 Computation Modes
-
-| Mode | Formula | Meaning |
-|------|---------|---------|
-| `weighted` | `center + mean(neighbors)` | Balanced perspective (default) |
-| `geometric` | `center × geo_mean(neighbors)` | Multiplicative relationships |
-| `harmonic` | `center + harmonic_mean(neighbors)` | Rate/ratio problems |
-| `median` | `center + median(neighbors)` | Robust to outliers |
-| `entropy` | `center × (1 + H(neighbors))` | Information content |
-| `minkowski` | `center + minkowski_dist(neighbors)` | Spatial distance |
-| `multiplicative` | `center × Π(neighbors)` | Product relationships |
-| `exponential` | `center × e^(mean(neighbors))` | Growth patterns |
-
-## API
-
-```typescript
-import { rei, Lexer, Parser, Evaluator } from 'rei-lang';
-
-// High-level API
-rei('𝕄{5; 1, 2, 3} |> compute');       // Evaluate code
-rei.parse('𝕄{5; 1, 2, 3}');             // Get AST
-rei.tokenize('42 |> sigma');             // Get token stream
-rei.reset();                              // Reset evaluator state
-
-// Low-level API
-const tokens = new Lexer(code).tokenize();
-const ast = new Parser(tokens).parseProgram();
-const ev = new Evaluator();
-const result = ev.eval(ast);
-```
-
-## Benchmarks
-
-Average **74% code reduction** compared to equivalent Python/JavaScript:
-
-| Task | Python/JS | Rei | Reduction |
-|------|-----------|-----|-----------|
-| Image kernel | 32 lines | 8 lines | 4× |
-| Multi-dim aggregation | 45 lines | 12 lines | 3.7× |
-| Graph transformation | 52 lines | 14 lines | 3.7× |
-| ETL pipeline | 50 lines | 16 lines | 3.1× |
-
-The center-periphery pattern `𝕄` being a language primitive is the fundamental advantage — what other languages build from loops, maps, and reduces, Rei expresses directly.
-
-## Theory
-
-Rei implements D-FUMT (Dimensional Fujimoto Universal Mathematical Theory) — a framework of 66 mathematical theories spanning pure mathematics to consciousness studies. The 25 Category C axioms formalize how values can:
-
-- **Know themselves** (C1: σ self-reference)
-- **Have tendencies** (C2: τ tracking)
-- **Respond to stimuli** (C3: response)
-- **Awaken through computation** (C4: awareness)
-- **Resonate non-locally** (C5: Indra's Net)
-
-For the full theoretical framework, see the [D-FUMT documentation on note.com](https://note.com/fc0web).
-
-## Version History
-
-| Version | Tests | Highlights |
-|---------|-------|-----------|
-| v0.1.0 | 85 | Core language: 𝕄, pipes, 0-extensions, Genesis |
-| v0.2.0 | 85 | Tetravalent logic, compression operators |
-| v0.2.1 | 91 | License fix, build optimization |
-| **v0.3.0** | **226** | **Space-Layer-Diffusion, Category C (25 axioms), Tier 1-5** |
-
-## License
-
-Apache-2.0 © Nobuki Fujimoto
+# Rei (0₀式) — D-FUMT Computational Language
+
+[![npm version](https://img.shields.io/npm/v/rei-lang)](https://www.npmjs.com/package/rei-lang)
+[![License: MIT](https://img.shields.io/badge/License-MIT-gold.svg)](./LICENSE)
+[![Tests](https://img.shields.io/badge/tests-85%2F85-brightgreen)]()
+
+**Rei** (0₀式 / れいしき) is a mathematical computation language based on **D-FUMT** (Dimensional Fujimoto Universal Mathematical Theory). Its center-periphery patterns as language primitives achieve an **average 74% code reduction** over equivalent implementations in general-purpose languages.
+
+**Author:** Nobuki Fujimoto
+
+---
+
+## Install
+
+```bash
+npm install rei-lang
+```
+
+## Quick Start
+
+### As a Library
+
+```typescript
+import { rei } from 'rei-lang';
+
+// Multi-dimensional number computation
+rei('let field = 𝕄{5; 1, 2, 3, 4}');
+const result = rei('field |> compute :weighted');
+console.log(result); // 7.5
+
+// Define functions with compress
+rei('compress energy(m) = m |> compute :weighted');
+rei('let e = energy(𝕄{0; 10, 20, 30})');
+console.log(rei('e')); // 20
+
+// Genesis axiom system
+rei('let g = genesis()');
+rei('g |> forward');
+rei('g |> forward');
+console.log(rei('g.state')); // "line"
+
+// Reset state between sessions
+rei.reset();
+```
+
+### Interactive REPL
+
+```bash
+npx rei
+```
+
+```
+ ╔══════════════════════════════════════════╗
+ ║  Rei (0₀式) REPL v0.2.0                  ║
+ ║  D-FUMT Computational Language           ║
+ ╚══════════════════════════════════════════╝
+
+零 > 𝕄{5; 1, 2, 3, 4} |> compute :weighted
+7.5
+
+零 > compress karma(i, e, r) = i * e * r
+compress karma(i, e, r)
+
+零 > karma(0.8, 0.9, 0.7)
+0.504
+```
+
+### Execute a File
+
+```bash
+npx rei program.rei
+```
+
+### Inline Evaluation
+
+```bash
+npx rei -e "2 + 3 * 4"
+# → 14
+```
+
+---
+
+## Language Features
+
+### Multi-Dimensional Numbers (𝕄)
+
+The core data structure. A center value with peripheral neighbors, computed in 4 modes:
+
+```rei
+let m = 𝕄{5; 1, 2, 3, 4}
+
+m |> compute :weighted       // center + weighted avg of neighbors
+m |> compute :multiplicative  // center × Π(1 + nᵢ)
+m |> compute :harmonic        // center + n / Σ(1/|nᵢ|)
+m |> compute :exponential     // center × avg(e^nᵢ)
+```
+
+### Extended Numbers (拡張数)
+
+Numbers with subscript-based dimensional extension:
+
+```rei
+let a = 0ooo       // 3rd-order extension of zero
+a >> :x >> :x      // extend: order 3 → 5
+a <<               // reduce: order 3 → 2
+a |> valStar       // numeric projection: 0.001
+
+πooo               // π extended to 3rd order
+0₀                 // D-FUMT zero symbol
+```
+
+### Compress (関数定義)
+
+Functions are defined with `compress` — reflecting D-FUMT's compression philosophy:
+
+```rei
+compress distance(x, y) = sqrt(x * x + y * y)
+compress field(c, r) = 𝕄{c; r, r, r, r}
+
+distance(3, 4)           // 5
+field(10, 2) |> compute :weighted  // 12
+```
+
+### Pipe Operator (|>)
+
+Center-to-periphery data flow:
+
+```rei
+-25 |> abs |> sqrt              // 5
+[3, 1, 2] |> sort |> reverse    // [3, 2, 1]
+"hello" |> upper                // "HELLO"
+𝕄{0; 1, 2, 3} |> normalize     // normalized neighbors
+```
+
+### Genesis Axiom System (生成公理系)
+
+Models computational emergence from void:
+
+```rei
+let g = genesis()   // void
+g |> forward        // void → dot
+g |> forward        // dot → line
+g |> forward        // line → surface
+g |> forward        // surface → solid
+g |> forward        // solid → omega (Ω)
+g.omega             // 1
+```
+
+Or from the primordial dot (・):
+
+```rei
+let g = ・
+g |> forward        // dot
+g |> forward        // line
+```
+
+### Four-Valued Logic (四価0π)
+
+Beyond true/false — Theory #21:
+
+```rei
+⊤           // true
+⊥           // false
+⊤π          // true-pi (π-rotated truth)
+⊥π          // false-pi
+
+¬⊤          // ⊥
+⊤ ∧ ⊥      // ⊥
+⊥ ∨ ⊤      // ⊤
+```
+
+### Variable Binding
+
+```rei
+let x = 42           // immutable
+let mut y = 10       // mutable
+```
+
+---
+
+## Benchmarks
+
+| Task | Conventional | Rei | Reduction |
+|------|-------------|-----|-----------|
+| Image kernel calculations | 32 lines | 8 lines | **4×** |
+| Multi-dimensional data aggregation | 45 lines | 12 lines | **3.7×** |
+| Graph structure transformation | 52 lines | 14 lines | **3.7×** |
+| **Average** | | | **74%** |
+
+---
+
+## API Reference
+
+### `rei(code: string): ReiValue`
+
+Evaluate a string of Rei code. State persists across calls.
+
+### `rei.reset(): void`
+
+Clear all variable and function bindings.
+
+### `rei.parse(code: string): ASTNode`
+
+Parse code and return the AST without evaluating.
+
+### `rei.tokenize(code: string): Token[]`
+
+Tokenize code and return the token stream.
+
+### Classes
+
+- `Lexer` — Tokenizer
+- `Parser` — Recursive descent parser
+- `Evaluator` — AST evaluator with environment/scope chain
+- `Environment` — Scope management
+
+### Types
+
+- `MultiDimNumber` — `{ center, neighbors, mode, weights? }`
+- `ReiExtended` — `{ base, order, subscripts, valStar() }`
+- `GenesisState` — `{ state, omega, history }`
+- `ReiFunction` — `{ name, params, body, closure }`
+- `Quad` — `{ value: 'top' | 'bottom' | 'topPi' | 'bottomPi' }`
+
+---
+
+## BNF Specification
+
+The complete BNF v0.2 specification is available in the repository.
+
+Key features integrated from 21 D-FUMT theories:
+- 45 keywords, 10 operators, 9 types
+- Full backward compatibility with v0.1
+- Complete operator precedence table
+
+---
+
+## Theoretical Foundation
+
+Rei is grounded in **D-FUMT** (Dimensional Fujimoto Universal Mathematical Theory), a framework of 66 interconnected theories spanning pure mathematics to philosophy and AI consciousness. The language's core innovation — **center-periphery patterns as language primitives** — derives from D-FUMT's multi-dimensional number system theory.
+
+---
+☮️ Peace Use Clause / 平和利用条項
+Rei is licensed under Apache 2.0 with an additional Peace Use Clause.
+Rei は Apache 2.0 ライセンスに加え、平和利用条項が適用されます。
+Rooted in the Buddhist concept of "Kū" (空, Emptiness) and D-FUMT's consciousness mathematics, Rei is designed exclusively for the peaceful advancement of humanity. This software may not be used for:
+仏教の「空」の概念と D-FUMT の意識数学に基づき、Rei は人類の平和的発展のためにのみ設計されています。以下の目的での使用は禁止されています：
+
+🚫 Weapons, military systems, or LAWS / 兵器・軍事システム・自律型致死兵器
+🚫 Human rights violations / 人権侵害
+🚫 Intentional environmental destruction / 意図的な環境破壊
+
+✅ Education, research, humanitarian aid, and creative endeavors are encouraged.
+✅ 教育・研究・人道支援・創造的活動での使用を推奨します。
+See PEACE_USE_CLAUSE.md for full details.
+
+MIT © Nobuki Fujimoto