A New Computational Schema for Euphonic Conjunctions in Sanskrit Processing

Automated language processing is central to the drive to enable facilitated referencing of increasingly available Sanskrit E texts. The first step towards processing Sanskrit text involves the handling of Sanskrit compound words that are an integral part of Sanskrit texts. This firstly necessitates the processing of euphonic conjunctions or sandhis, which are points in words or between words, at which adjacent letters coalesce and transform. The ancient Sanskrit grammarian Panini’s codification of the Sanskrit grammar is the accepted authority in the subject. His famed sutras or aphorisms, numbering approximately four thousand, tersely, precisely and comprehensively codify the rules of the grammar, including all the rules pertaining to sandhis. This work presents a fresh new approach to processing sandhis in terms of a computational schema. This new computational model is based on Panini’s complex codification of the rules of grammar. The model has simple beginnings and is yet powerful, comprehensive and computationally lean.

💡 Research Summary

The paper addresses the fundamental problem of processing Sanskrit sandhi (euphonic conjunctions) in the context of the growing availability of Sanskrit electronic texts. Recognizing that sandhi handling is the first prerequisite for any higher‑level natural‑language processing task, the authors propose a novel computational schema that directly encodes Panini’s original sutras rather than relying on derived models such as finite‑state machines, hidden Markov models, or neural networks.

The core idea is to assign a unique integer value (1‑51) to each Sanskrit phoneme based on the order given in the fourteen Maheśvara aphorisms, which are themselves a mnemonic ordering of the alphabet. Table 1 in the paper lists these values. The phonemes are further grouped into 19 categories (vowels, consonants, semi‑vowels, nasals, hard/soft consonants, etc.) to facilitate rule classification.

Sandhi transformations are divided into four linguistic operations—addition (gama), substitution (adesha), deletion (lopa), and no‑change (prakṛtibhāva). For computational purposes the authors ignore the no‑change case and focus on the first three. They then introduce five rule categories (C1‑C5):

• C1 – replace both adjacent letters (x + y) with a single or multi‑letter result z.
• C2 – replace the first letter x with z.
• C3 – replace the second letter y with z.
• C4 – insert a letter z between x and y.
• C5 – delete the first letter x.

Each category is represented by a generic binary operator ⊕₁ … ⊕₅. To capture the fact that a single sandhi type may be governed by multiple sutras and each sutra may contain several equations, the authors add two additional subscripts, yielding operators of the form ⊕ᵢ,ⱼ (for sutra j in category i) and ⊕ᵢ,ⱼ,ₖ (for the k‑th equation of sutra j). This notation allows them to express every sandhi rule as a compact arithmetic expression involving the integer values of the letters and, when necessary, the values of surrounding letters (u, w) or whole‑word contexts (X, Y).

Using this framework the authors enumerate 49 sutras that cover the major sandhi types and derive a total of 2,413 concrete rule equations. Table 2 shows the distribution of rules across categories (e.g., 1,439 rules belong to C1, 397 to C2, etc.). Sample rules are presented for several well‑known sandhi groups:

• Guṇa sandhi (e.g., a + i → e) is encoded as ⊕₁,₁,₁ with z₁ = 10 for i, u and z₁ = 11 for e, o.
• Vṛddhi sandhi (e.g., a + e → ai) uses ⊕₁,₃ with conditional formulas that add 2 to the second vowel’s value.
• Pararūpa sandhi, which depends on preceding prepositions, incorporates whole‑word context variables X and Y.
• Savarṇadīrgha sandhi (identical vowels) is handled by a commutative operator ⊕₁,₈ that maps short‑long vowel pairs to their long counterpart.

The authors argue that because the model works directly with integer codes, the computational overhead is minimal (“computationally lean”). They also claim that the schema is exhaustive for the major sandhi phenomena and can be directly implemented in a sandhi generator or splitter.

However, the paper lacks empirical validation. No runtime benchmarks, memory usage statistics, or accuracy measurements on real Sanskrit corpora (e.g., GRETIL) are provided. The handling of Unicode is mentioned only superficially; the implementation uses a Latin‑based transliteration scheme, leaving the conversion from Devanagari or other scripts to the internal numeric representation as an external step. The sheer number of rules (≈2,500) raises concerns about maintainability and the potential for combinatorial explosion when integrating with larger NLP pipelines. Moreover, the paper does not compare its approach against existing FSM, HMM, or neural methods, making it difficult to assess whether the proposed “lean” model offers any practical advantage in speed or accuracy.

In summary, the contribution of the paper is a systematic, mathematically formalized encoding of Paninian sandhi rules using a numeric alphabet and a hierarchy of binary operators. This representation is novel and academically faithful to the original grammar, offering a clear pathway to implement a rule‑based sandhi engine. To become truly useful for modern Sanskrit NLP, future work should address:

1. Full Unicode (Devanagari) support and automated transliteration.
2. Performance evaluation on large, diverse corpora with precision/recall metrics.
3. Integration of exception handling for irregular forms and loanwords.
4. Comparative experiments with established finite‑state or machine‑learning sandhi systems.
5. Development of a clean API or library that abstracts the complex ⊕ᵢ,ⱼ,ₖ notation into programmer‑friendly functions.

With these extensions, the proposed schema could serve as a robust backbone for Sanskrit morphological analyzers, machine translation front‑ends, and digital humanities tools that require reliable sandhi processing.