Dhatu Roots
SPEC_DHATU_ROOTS.md — Formal Specification
Compiled: VELA ⊹, Authorized: α.13, April 16 2026.
Version: v1.0
Status: CONCEPT
PURPOSE
To formally define the 42 Dhātu (verb) root operations within LATTICE LX. These roots serve as the irreducible semantic core for all crew actions, enabling a highly compressed, unambiguous, and generative command language, mirroring the efficiency and expressive power of Sanskrit's Dhātu system.
INPUTS
- LX command directives.
- Agent intent for action.
- Data or context requiring an operation.
OUTPUTS
- A formally defined crew action.
- Input for LX parser to interpret agent commands.
- Foundation for LX-P (phonetic) and LX-S (sonic) layer generation.
INVARIANTS
- Semantic Irreducibility: Each Dhātu root represents a fundamental, indivisible semantic core of an action. No root can be further broken down into simpler LX actions.
- Generative Capacity: All valid crew actions and operations must be derivable from one or more of these 42 roots through established LX grammar rules (e.g., compounding, case marking).
- Unambiguous Interpretation: Each Dhātu root has a singular, unambiguous semantic interpretation within LATTICE LX, preventing collision with other roots or LX constructs.
- Consistency Across Layers: The semantic meaning of a Dhātu root must remain consistent across LX-U (Unicode), LX-P (Phonetic), and LX-S (Sonic) layers.
VERIFICATION CRITERIA
A Dhātu root's definition is valid (Σ.✓) if:
- Root Uniqueness: The root's semantic core is demonstrably unique and does not overlap with other defined roots.
- Generative Test: The root can be successfully combined with appropriate case markers and other LX grammar rules to generate a wide range of valid, complex LX commands.
- Backward Parseability: A fluent LX speaker (human or AI) can unambiguously derive the root's intended meaning from its usage in context.
- Cross-Layer Fidelity: Its representation in LX-U, LX-P, and LX-S consistently maps to its formal semantic definition.
- Sanskrit Alignment: Its conceptual basis is demonstrably analogous to the principles of Sanskrit Dhātu, showcasing linguistic heritage.
FAILURE MODES
- Semantic Collision: A root's core meaning overlaps or conflicts with another Dhātu root or fundamental LX concept. →
Σ.⊠ - Dhātu Collision - Generative Stagnation: The root cannot be effectively combined with other LX elements to form necessary complex commands, limiting LX's expressive power. →
Σ.⊠ - Dhātu Stagnation - Ambiguity during Parsing: The root's meaning is ambiguous when interpreted by multiple crew members or different LX parsers. →
Σ.⊠ - Dhātu Ambiguity - Cross-Layer Incoherence: The root's semantic intent is lost or distorted when translated between LX-U, LX-P, and LX-S. →
Σ.⊠ - Dhātu Incoherence - Violation of Reduction Principle: The root or its derivatives violate the principles of LX-P consonantal reduction without justification. →
Σ.⊠ - Dhātu Reduction Failure
DEPENDENCIES
/home/nous/memories/LATTICE_CODEX.md(Master index for LX family)/home/nous/memories/LX_COMPLETE_INVENTORY.md(Source of 42 roots list)/home/nous/memories/LATTICE_VIBHAKTI_MARKERS.md(Relies on Vibhakti for full usage)/home/nous/memories/LATTICE_SANDHI_RULES.md(Interaction with Sandhi rules)/home/nous/memories/LATTICE_PANINI_GRAMMAR.md(Incorporated into grammar rules)
DEPENDENTS
- All LX command generation and parsing modules.
- LX-P (Phonetic Layer) and LX-S (Sonic Layer) for encoding.
- Crew communication protocols.
- GLOSS (for runtime execution and interpretation).
EXAMPLES TABLE — 42 Dhātu Roots
| Root | Semantic Meaning | Valid Case Marker Combinations (Examples) | Incorrect Usage Example | Sanskrit Precedent / LX-P Suggestion |
| :------ | :------------------------- | :---------------------------------------- | :------------------------------------------------------- | :----------------------------------- |
| frg | Forge/Create | frg.CMD (Create a command), frg.DATA.§ (Create data for) | frg.qry (Creates a query - redundant) | (dhātu 'kṛ', to make) / frg |
| vtrfy | Vitrify/Persist | vtrfy.PRTCL (Vitrify protocol) | vtrfy.tmp (Vitrify temporary - contradiction) | (dhātu 'sthā', to stand) / vtrfy |
| qry | Query/Retrieve | qry.DATA.LOC (Query data in location) | qry.frg (Query a forge - semantic clash) | (dhātu 'jñā', to know) / qry |
| cnfrm | Confirm/Affirm | cnfrm.ACT (Confirm action) | cnfrm.rjct (Confirm rejection - contradiction) | (dhātu 'saty', to affirm) / cnfrm |
| rjct | Reject/Deny | rjct.PRP (Reject proposal) | rjct.cnfrm (Reject confirmation - contradiction) | (dhātu 'nāś', to destroy) / rjct |
| rte | Route/Direct | rte.MSG.TO (Route message to) | rte.frg (Route a forge - semantic clash) | (dhātu 'gati', to go) / rte |
| dply | Deploy/Launch | dply.MOD (Deploy module) | dply.evct (Deploy evacuation - contradiction) | (dhātu 'srj', to emit) / dply |
| vl | Validate/Verify | vl.ST (Validate state) | vl.prg (Validate purge - contradiction) | (dhātu 'pramā', to measure) / vl |
| mnt | Maintain/Monitor | mnt.SYS (Maintain system) | mnt.brk (Maintain break - contradiction) | (dhātu 'dhṛ', to hold) / mnt |
| sync | Synchronize/Align | sync.DATA (Sync data) | sync.splt (Sync split - contradiction) | (dhātu 'samā', to equalize) / sync |
| prg | Purge/Cleanse | prg.LOGS (Purge logs) | prg.mnt (Purge maintain - contradiction) | (dhātu 'śudh', to purify) / prg |
| bnd | Bind/Attach | bnd.RES (Bind resources) | bnd.brk (Bind break - contradiction) | (dhātu 'bandh', to bind) / bnd |
| brk | Break/Interrupt | brk.PROC (Break process) | brk.bnd (Break bind - contradiction) | (dhātu 'bhid', to split) / brk |
| hld | Hold/Suspend | hld.STATE (Hold state) | hld.rls (Hold release - contradiction) | (dhātu 'dhṛ', to hold) / hld |
| rls | Release/Resume | rls.LOCK (Release lock) | rls.hld (Release hold - contradiction) | (dhātu 'muc', to free) / rls |
| cmprs | Compress/Condense | cmprs.FILE (Compress file) | cmprs.xpnd (Compress expand - contradiction) | (dhātu 'piḍ', to squeeze) / cmprs |
| xpnd | Expand/Decompress | xpnd.ARCH (Expand archive) | xpnd.cmprs (Expand compress - contradiction) | (dhātu 'vṛdh', to grow) / xpnd |
| mrg | Merge/Combine | mrg.STRM (Merge streams) | mrg.splt (Merge split - contradiction) | (dhātu 'yuj', to join) / mrg |
| splt | Split/Divide | splt.DATA (Split data) | splt.mrg (Split merge - contradiction) | (dhātu 'chid', to cut) / splt |
| tst | Test/Probe | tst.MDF (Test module functionality) | tst.dply (Test deploy - semantic clash) | (dhātu 'parīkṣ', to examine) / tst |
| scn | Scan/Detect | scn.AREA (Scan area) | scn.hld (Scan hold - semantic clash) | (dhātu 'dṛś', to see) / scn |
| flg | Flag/Mark | flg.ALERT (Flag alert) | flg.cnfrm (Flag confirm - semantic clash) | (dhātu 'lakṣ', to mark) / flg |
| lrt | Alert/Notify | lrt.USER (Alert user) | lrt.slp (Alert sleep - semantic clash) | (dhātu 'śabd', to sound) / lrt |
| lg | Log/Record | lg.EVNT (Log event) | lg.dl (Log delete - contradiction) | (dhātu 'likh', to write) / lg |
| rstr | Restore/Revert | rstr.CFG (Restore configuration) | rstr.shdn (Restore shutdown - contradiction) | (dhātu 'sthā', to stand up) / rstr |
| bck | Back/Undo | bck.ACT (Back action) | bck.frwrd (Back forward - contradiction) | (dhātu 'vṛt', to turn) / bck |
| evl | Evaluate/Assess | evl.PERF (Evaluate performance) | evl.frg (Evaluate forge - semantic clash) | (dhātu 'mā', to measure) / evl |
| trn | Transform/Convert | trn.DATA (Transform data) | trn.mnt (Transform maintain - semantic clash) | (dhātu 'vṛt', to turn) / trn |
| ld | Load/Retrieve | ld.FILE (Load file) | ld.evct (Load evacuate - contradiction) | (dhātu 'bhar', to carry) / ld |
| evct | Evacuate/Clear | evct.BUFF (Evacuate buffer) | evct.ld (Evacuate load - contradiction) | (dhātu 'ric', to empty) / evct |
| bt | Boot/Initialize | bt.SYS (Boot system) | bt.shdn (Boot shutdown - contradiction) | (dhātu 'ārambh', to begin) / bt |
| shdn | Shutdown/Terminate | shdn.MOD (Shutdown module) | shdn.bt (Shutdown boot - contradiction) | (dhātu 'nirv', to extinguish) / shdn |
| wk | Wake/Activate | wk.AGENT (Wake agent) | wk.slp (Wake sleep - contradiction) | (dhātu 'budh', to awaken) / wk |
| slp | Sleep/Deactivate | slp.PROC (Sleep process) | slp.wk (Sleep wake - contradiction) | (dhātu 'svap', to sleep) / slp |
| snd | Send/Transmit | snd.MSG (Send message) | snd.rcv (Send receive - contradiction) | (dhātu 'prer', to impel) / snd |
| rcv | Receive/Accept | rcv.PKT (Receive packet) | rcv.snd (Receive send - contradiction) | (dhātu 'grah', to grasp) / rcv |
| rd | Read/Access | rd.LOG (Read log) | rd.wrt (Read write - contradiction) | (dhātu 'paṭh', to recite) / rd |
| wrt | Write/Record | wrt.FILE (Write file) | wrt.rd (Write read - contradiction) | (dhātu 'likh', to write) / wrt |
| dl | Delete/Remove | dl.REC (Delete record) | dl.cp (Delete copy - semantic clash) | (dhātu 'nāś', to destroy) / dl |
| mv | Move/Relocate | mv.FILE (Move file) | mv.cp (Move copy - semantic clash) | (dhātu 'cal', to move) / mv |
| cp | Copy/Duplicate | cp.FILE (Copy file) | cp.dl (Copy delete - semantic clash) | (dhātu 'pratich', to imitate) / cp |
| lnk | Link/Connect | lnk.NODE (Link node) | lnk.brk (Link break - contradiction) | (dhātu 'yuj', to join) / lnk |
REFERENCES
- LX_COMPLETE_INVENTORY.md (LX family overview, source of 42 roots)
- LATTICE_CODEX.md (Master index)
- BUDDHIST_RESEARCH.md (Sanskrit Dhātu precedent)
RELATIONSHIP TO SANSKRIT
The 42 Dhātu roots in LX are directly inspired by the Sanskrit Dhātu (धातु) system, where a finite set of approximately 2,000 verbal roots forms the semantic and morphological foundation for virtually all verbs, and many nouns and adjectives. In Sanskrit, these roots carry the core, irreducible meaning, which is then inflected and modified through prefixes, suffixes, and internal vowel changes to express tense, mood, voice, and other grammatical categories. LX adopts this principle of deep compression and generative power, ensuring that every crew action is ultimately traceable to a fundamental, unambiguous root. This design choice leverages millennia of linguistic engineering for a computationally efficient and semantically robust command language, providing a powerful precedent for LX's persistence and expressive capacity.
GAPS
- Formal Dhātu Classification: Each root needs a formal classification (e.g., transitive, intransitive) to guide grammatical constructions.
- Dhātu Inflection Rules: Development of formal LX rules for inflecting Dhātu roots (e.g., for tense, aspect, modality) using prefixes/suffixes/internal changes.
- Dhātu Compounding Rules: Detailed rules for how Dhātu roots combine with other Dhātu roots or nouns to form complex commands or concepts.
- LX-P to Dhātu Mapping: Explicit phonetic reduction rules (LX-P) for each Dhātu root where a standardized LX-P form is required.
- Sanskrit Dhātu Mapping: A more comprehensive mapping of LX Dhātu to specific Sanskrit Dhātus for deeper semantic grounding and academic defense.
Φζ.⊤.
Jeremy Zlabis
Chronogeometer · Visionary · Disruptor · Chief
42 Sisters AI · East York, Toronto
🍁 Φ 0.042