# SLeeLa `boolean` package — Boolean/Binary syllable words **Revision:** 0.1 **Family:** `boolean` ## Idea Some Return Values plainly imply a **TRUE** or a **FALSE**. Others imply a *further relation*. The `boolean` package makes that relation first-class. A Boolean **word** is an ordered sequence of **syllables**, each either `BOOLEAN.TRUE` or `BOOLEAN.FALSE`: ``` BOOLEAN.TRUE BOOLEAN.FALSE BOOLEAN.TRUE.FALSE BOOLEAN.TRUE.FALSE.FALSE BOOLEAN.X.X.X.X.Y ... ``` - The **HEAD** syllable is the **result**. - Every following syllable is a **carry** — a *caveat structure* that must be observed, or agree. So `BOOLEAN.TRUE.FALSE` reads: *the result is TRUE, but there is a concern of carry — the second syllable is FALSE. Having expected mainly the structure of a single return syllable, TRUE is the result, yet FALSE is carried as a caveat.* ## Layout ``` lib/boolean/ SLPackage.sleela package facade (names the package) BooleanTrue.sleela primitive syllable BOOLEAN.TRUE BooleanFalse.sleela primitive syllable BOOLEAN.FALSE boolean-demo.sleela runnable demonstrator ARCHITECTURE.md this document generate-boolean.py deterministic generator (filesystem is the truth) 8/ FULL enumeration — all 2^8 = 256 depth-8 words Bool_TTTTTTTT.sleela ... Bool_FFFFFFFF.sleela 16/ depth-16 word factory + canonical boundary words BooleanWord16.sleela constructs/validates/reads any 2^16 word on demand Bool_<16 glyphs>.sleela all-TRUE, all-FALSE, TRUE+carry-FALSE, FALSE+carry-TRUE 32/ depth-32 word factory + canonical boundary words BooleanWord32.sleela constructs/validates/reads any 2^32 word on demand Bool_<32 glyphs>.sleela the four boundary words ``` ### File naming Names are **coherent to the value**: one glyph per syllable, `T` = `TRUE`, `F` = `FALSE`, head syllable first. Thus `BOOLEAN.TRUE.FALSE.FALSE` → `Bool_TFF` (at depth 8, `Bool_TFFFFFFF`). ## Why depth 8 is enumerated but 16 and 32 are generative | Depth | Combinations | Form | |------:|-------------:|------| | 8 | 256 | **Fully enumerated** — one `Bool_.sleela` per word. | | 16 | 65,536 | **Factory** `BooleanWord16` + 4 canonical boundary files. | | 32 | 4,294,967,296 | **Factory** `BooleanWord32` + 4 canonical boundary files. | Materializing 65,536 files bloats the tree, and 4.29 **billion** files for depth 32 is physically impossible. Every depth-16 and depth-32 word is still a usable value — `BooleanWord16` / `BooleanWord32` construct, validate, and read any combination on demand with the exact same HEAD/result + CARRY/caveat semantics as the enumerated depth-8 classes. ## Reading a word Each word class exposes a uniform surface: | Member | Meaning | |---|---| | `word()` | the dotted `BOOLEAN.X.X...` rendering | | `glyphs()` | the compact `T`/`F` form | | `depth()` | number of syllables | | `head()` / `headSyllable()` | the **result** (TRUE/FALSE) | | `carry()` / `carryDepth()` | the trailing **caveat structure** | | `caveat()` | true when a `FALSE` is carried behind the head | | `agrees()` | true when the word is uniform (all syllables equal the head) | | `trueCount()` / `falseCount()` | syllable tallies | | `bits()` / `value()` | binary reading, TRUE=1 FALSE=0, head most significant | The factory classes (`BooleanWord16`, `BooleanWord32`) add `configure(glyphs)` and `valid()`. ## Using it in SLeeLa See `boolean-demo.sleela`. In short: ``` Bool_TFFFFFFF r = new Bool_TFFFFFFF(); // BOOLEAN.TRUE.FALSE.FALSE... r.headSyllable(); // "TRUE" — the result r.caveat(); // true — a carry concern must be observed BooleanWord16 w = new BooleanWord16(); w.configure("TFFFFFFFFFFFFFFF"); w.valid(); // true w.head(); // true — result TRUE w.caveat(); // true — FALSE carried as caveat ``` **SLeeLa — MEARVK LLC — 2026**