Strilight (v0.2.0)

Python और C के लिए उच्च-प्रदर्शन बीजगणितीय लूप लिफ्टिंग और सटीक परिमेय पुनरावृत्ति इंजन

---

अवलोकन: जब आप हल कर सकते हैं तो पुनरावृत्ति क्यों करें?

पारंपरिक कंपाइलर, रनटाइम और JIT इंजन (जैसे GCC, Clang, PyPy, या Numba) लूप को दोहराव वाले नियंत्रण-प्रवाह अनुक्रमों के रूप में मानते हैं, और निर्देशों को चरण-दर-चरण निष्पादित करते हैं:

$$ \text{Runtime Cost} = \mathcal{O}(N) $$

जब $N = 10^6$ या $10^9$ हो, तो अनुक्रमिक निष्पादन अरबों CPU चक्रों का खर्च उठाता है। Strilight प्रतीकात्मक बीजगणितीय लिफ्टिंग के माध्यम से लूप निष्पादन को मूल रूप से पुनः इंजीनियर करता है:

1. अवस्था संक्रमण सूत्रीकरण: यह लूप बॉडी का स्थिर रूप से निरीक्षण करता है और उसका गणितीय अवस्था संक्रमण मैट्रिक्स तैयार करता है:

$$ \vec{\mathbf{X}}(N) = \mathbf{A}^N \cdot \vec{\mathbf{X}}0 + \sum{k=0}^{N-1} \mathbf{A}^{N-1-k} \vec{\mathbf{B}} $$

2. संवृत-रूप समाधान: यह पुनरावृत्ति प्रणाली को संवृत रूप में हल करता है, जिससे निष्पादन समय $\mathcal{O}(N)$ से घटकर $\mathcal{O}(1)$ (स्केलर/आवधिक/टेलीस्कोपिंग श्रेणियों के लिए) या $\mathcal{O}(\log N)$ (तेज़ बाइनरी मैट्रिक्स एक्सपोनेंशिएशन के माध्यम से) हो जाता है।

---

डिज़ाइन दर्शन: सर्वप्रथम डेवलपर जीवन-गुणवत्ता

Strilight गूढ़ जादू पेश करने का दावा नहीं करता; यह मूल रूप से एक डेवलपर जीवन-गुणवत्ता उपकरण है।

भौतिक मॉडलिंग, वैज्ञानिक कंप्यूटिंग और संख्यात्मक सिमुलेशन में, इंजीनियरों को अक्सर एक निराशाजनक दुविधा का सामना करना पड़ता है:

• पठनीय कोड: स्वाभाविक, अभिव्यक्तिपूर्ण समीकरण जो पाठ्यपुस्तक भौतिकी को प्रतिबिंबित करते हैं, लेकिन लाखों बार पुनरावृत्त होने पर धीमी गति से निष्पादित होते हैं।
• हस्त-अनुकूलित कोड: जटिल, मैन्युअल रूप से अनरोल किए गए लूप और अस्पष्ट अंकगणितीय शॉर्टकट जो तेज़ चलते हैं, लेकिन भंगुर, डिबग करने में कठिन और अंतर्निहित भौतिकी को अस्पष्ट करने वाले होते हैं।

Strilight इस दुविधा का समाधान करता है। आप भौतिक या गणितीय अवधारणा को जिस भी सरल, स्वाभाविक सिंटैक्स में पसंद करें, उसमें लिखें। Strilight आपकी लूप संरचना का निरीक्षण करता है, सटीक संवृत-रूप पुनरावृत्ति सूत्र प्राप्त करता है, और पर्दे के पीछे निष्पादन को तेज़ करता है—आपके कोडबेस में पूर्ण पठनीयता और सरलता को बनाए रखते हुए।

---

स्थापत्य नींव

1. $\mathbb{Q}$ पर सटीक परिमेय अंकगणित (शून्य परिशुद्धता हानि)

फ्लोटिंग-पॉइंट अंकगणित संचयी ट्रंकेशन त्रुटियाँ उत्पन्न करता है ($1/3 \times 3 \approx 0.9999999999999999$)। Strilight परिमेय संख्याओं के क्षेत्र $\mathbb{Q}$ पर एफ़िन इंडक्शन और स्ट्राइड विश्लेषण करता है:

• गुणक और ऑफ़सेट विहित भिन्नों ($\frac{p}{q}$) के रूप में मॉडल किए जाते हैं।
• C में डबल-प्रिसिजन कर्नेल और Python में सटीक Fraction निरूपण उत्सर्जित करता है, जो 100% बिट-सटीक गणितीय समानता की गारंटी देता है।

2. बहु-चर युग्मित पुनरावृत्ति प्रणालियाँ ($\mathcal{O}(\log N)$)

जो चर परस्पर एक-दूसरे पर निर्भर होते हैं (जैसे, भौतिक सिमुलेशन जहाँ स्थिति वेग पर निर्भर करती है और वेग त्वरण पर निर्भर करता है) उन्हें स्वचालित रूप से एक चर युग्मन मैट्रिक्स ($\mathbf{A}$) में निकाला जाता है। Strilight $\mathbf{A}$ पर बाइनरी एक्सपोनेंशिएशन करता है, जिससे लाखों पुनरावृत्तियाँ 2 नैनोसेकंड से कम समय में निष्पादित होती हैं।

3. पारदर्शी @accelerate डेकोरेटर (यह कैसे काम करता है)

किसी भी मानक Python फ़ंक्शन को @accelerate से सजाने पर फ़ंक्शन परिभाषा के समय एक स्वचालित पाइपलाइन निष्पादित होती है (प्रति-कॉल रनटाइम विश्लेषण ओवरहेड शून्य):

1. AST निष्कर्षण: फ़ंक्शन के AST का निरीक्षण करता है, for लूप संरचनाओं की पहचान करता है, और इंडक्शन वेरिएबल्स निकालता है।
2. क्लोज़्ड-फ़ॉर्म संश्लेषण: लूप को समतुल्य क्लोज़्ड-फ़ॉर्म पुनरावृत्ति मॉडल या बाइनरी मैट्रिक्स एक्सपोनेंशिएशन कर्नेल में अनुवादित करता है।
3. इन-प्लेस स्प्लाइसिंग: लूप के AST नोड्स को इन-प्लेस प्रतिस्थापित करता है, कॉलेबल को मेमोरी में कंपाइल करता है, और मॉड्यूल नेमस्पेस को प्रदूषित किए बिना रनटाइम ग्लोबल्स (Fraction, math) इंजेक्ट करता है।
4. कॉन्ट्रैक्ट रिफ्लेक्शन: कंपाइल किए गए फ़ंक्शन ऑब्जेक्ट पर _loop_summary और _invariant_contract संलग्न करता है, जिससे डाउनस्ट्रीम कंपाइलर और सत्यापन उपकरण अंतर्निहित ट्रांज़िशन मैट्रिक्स $\mathbf{A}$ का निरीक्षण कर सकें।
5. सौम्य फ़ॉलबैक: यदि गैर-रेखीय इंडेक्सिंग या असमर्थित डायनामिक कॉल्स का सामना होता है, तो Strilight एक डायग्नोस्टिक चेतावनी जारी करता है और क्रैश किए बिना सफ़ाई से नेटिव निष्पादन पर वापस लौट आता है।

from strilight import accelerate

@accelerate
def compute_simulation(steps: int) -> int:
    acc = 0
    for i in range(steps):
        acc += (i * 3) + 7
    return acc

# Executes in O(1) time (~0.001 ms even if steps = 100,000,000)
result = compute_simulation(100_000_000)

4. अनुबंध-निर्देशित C स्रोत निर्देश (#pragma strilight)

Python के गतिशील रिफ्लेक्शन के विपरीत, Strilight में C कोड रूपांतरण OpenMP-शैली के pragma निर्देशों के माध्यम से एक स्पष्ट Developer-Contract Model का सख्ती से पालन करते हैं। इंजन कभी भी C स्रोत कोड को अंतर्निहित रूप से परिवर्तित नहीं करता; रूपांतरण केवल तभी होते हैं जब स्पष्ट डेवलपर अनुबंध खंडों (contract, target, include, model) द्वारा निर्देशित किया जाता है:

• #pragma strilight accelerate: Strilight को स्पष्ट रूप से अधिकृत करता है कि वह एनोटेटेड C for लूप को एक समतुल्य बंद-रूप गणितीय अभिव्यक्ति में उठाए।
• #pragma strilight fuse: स्पष्ट डेवलपर निर्देश जो Strilight को निर्देश देता है कि समान पुनरावृत्ति डोमेन साझा करने वाले निर्दिष्ट आसन्न लूपों को एक एकीकृत $\mathcal{O}(\log N)$ बाइनरी मैट्रिक्स पुनरावृत्ति कर्नेल में संयोजित करे।

// Example of contract-guided multi-loop fusion via developer directive
int simulate_motion(int n) {
    int pos = 0, vel = 10;

    #pragma strilight fuse
    for (int i = 0; i < n; i++) {
        pos += vel;
    }
    for (int i = 0; i < n; i++) {
        vel += 2;
    }
    return pos;
}

5. क्रॉस-फ़ाइल सिंबल और कॉन्स्टेंट रिज़ॉल्यूशन (CrossFileResolver)

संख्यात्मक सिमुलेशन अक्सर अलग-अलग हेडर फ़ाइलों या कॉन्फ़िगरेशन मॉड्यूल में पैरामीटर परिभाषित करते हैं। Strilight का CrossFileResolver:

• स्थानीय मॉड्यूल इम्पोर्ट और C #include / #define निर्देशों को स्टैटिक रूप से ट्रेस करता है।
• मनमाना रनटाइम कोड निष्पादित किए बिना या असुरक्षित eval का उपयोग किए बिना, AST मूल्यांकन के माध्यम से फ़ाइलों में लिटरल कॉन्स्टेंट एक्सप्रेशन (जैसे SOLAR_MASS = 4 * PI * PI) का मूल्यांकन करता है।

6. ऐरे स्लाइस इंडक्शन और साइक्लिक टेबल लुकअप

• साइक्लिक ऐरे लुकअप: साइक्लिक टेबल लुकअप (table[i % P]) को $\mathcal{O}(1)$ में पूर्व-गणित प्रीफ़िक्स-सम क्लोज़्ड फ़ॉर्मूला में उठाता है।
• इन-प्लेस ऐरे स्लाइस म्यूटेशन: कॉन्स्टेंट फ़िल और अंकगणितीय प्रगति को वर्गीकृत करता है, इष्टतम हार्डवेयर memset कॉल या वेक्टर स्लाइस असाइनमेंट (arr[:N] = ...) को संश्लेषित करता है।