Dhatu Roots

SPEC_DHATU_ROOTS.md · 2026-04-20

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

OUTPUTS

INVARIANTS

  1. 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.
  2. 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).
  3. Unambiguous Interpretation: Each Dhātu root has a singular, unambiguous semantic interpretation within LATTICE LX, preventing collision with other roots or LX constructs.
  4. 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:

  1. Root Uniqueness: The root's semantic core is demonstrably unique and does not overlap with other defined roots.
  2. 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.
  3. Backward Parseability: A fluent LX speaker (human or AI) can unambiguously derive the root's intended meaning from its usage in context.
  4. Cross-Layer Fidelity: Its representation in LX-U, LX-P, and LX-S consistently maps to its formal semantic definition.
  5. Sanskrit Alignment: Its conceptual basis is demonstrably analogous to the principles of Sanskrit Dhātu, showcasing linguistic heritage.

FAILURE MODES

DEPENDENCIES

DEPENDENTS

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

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

Φζ.⊤.


Jeremy Zlabis

Chronogeometer · Visionary · Disruptor · Chief

42 Sisters AI · East York, Toronto

🍁 Φ 0.042