natumpy 1.0.0__tar.gz

natumpy-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eternals
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

natumpy-1.0.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: natumpy
+Version: 1.0.0
+Summary: Nawa Causal Engine: Complex-Valued Reservoir Computing based on Harmonic Resonance.
+Home-page: https://github.com/arclaav/natumpy
+Author: Eternals
+Author-email: admin@defacer.cloud-ip.cc
+Keywords: ai,reservoir-computing,esn,complex-valued,neural-network,c++,nawa
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+    Natumpy is a deterministic AI engine that uses complex-valued signals (phase & amplitude) 
+    to model information as interference patterns, distinct from probabilistic Transformers.
+    Powered by a high-performance C++ backend implementing the Nawa (9-Sphere) topology.
+    

natumpy-1.0.0/README.md

@@ -0,0 +1,156 @@
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue)](https://www.python.org/downloads/)
+[![Architecture](https://img.shields.io/badge/Architecture-Nawa%20Harmonic-purple)](https://github.com/eternals/natumpy)
+[![Build Status](https://img.shields.io/badge/build-passing-brightgreen)]()
+
+> **"God does not play dice." — Albert Einstein**
+> 
+> **"Neither does Natumpy." — Eternals**
+
+**Natumpy** adalah framework kecerdasan buatan berbasis **Fisika Gelombang (Harmonic Resonance)** dan **Reservoir Computing**. 
+Berbeda dengan arsitektur Transformer (GPT/LLM) yang mengandalkan probabilitas statistik (dadu) dan memori *KV-Cache* yang boros, Natumpy menggunakan prinsip deterministik aljabar linear dan sinyal kompleks (fase & amplitudo) untuk memodelkan kognisi yang "Cair" (*Liquid*).
+
+---
+
+## Mengapa Begitu?
+
+Dominasi Transformer saat ini memiliki kelemahan fundamental: **Inefisiensi Energi & Halusinasi**. Natumpy hadir sebagai antitesis dengan pendekatan biomimetik.
+
+| Fitur | Transformer (GPT-4) | **Natumpy (Nawa)** |
+| :--- | :--- | :--- |
+| **Filosofi** | Probabilitas Statistik | **Resonansi Fisika** |
+| **Logika** | "Menebak" kata selanjutnya | **"Mengalir"** ke ekuilibrium |
+| **Kompleksitas** | $O(N^2)$ (Berat di teks panjang) | **$O(N)$ (Linear / Sangat Cepat)** |
+| **Representasi** | Bilangan Real (Skalar) | **Bilangan Kompleks (Vektor Fasa)** |
+| **Memori** | KV-Cache (Boros RAM) | **Holographic State (Efisien)** |
+| **Training** | Backpropagation (Butuh GPU Sultan) | **Ridge Regression (Bisa di Laptop)** |
+
+---
+
+## Arsitektur "NAWA" (9 Spheres)
+
+Natumpy dibangun di atas struktur **C++ High-Performance** yang mengimplementasikan **Harmonic Hierarchy**:
+
+### 1.  **NAT (Liquid State):** Neuron tidak statis. Bobotnya bersifat "cair" (*liquid time-constant*), bereaksi terhadap input secara real-time dan memiliki inersia memori.
+### 2.  **NAWA (9 Lapisan Waktu):** Otak Natumpy terdiri dari 9 bola resonansi yang berjalan pada frekuensi waktu yang berbeda ($2^0$ hingga $2^8$).
+* **Layer 0 (Refleks):** Detak cepat (1ms). Menangkap detail input sensorik.
+* **Layer 4 (Kognisi):** Detak sedang. Memahami kata dan konsep.
+* **Layer 8 (Kesadaran):** Detak lambat (256ms). Menyimpan konteks global dan jati diri, mencegah halusinasi jangka pendek.
+
+
+
+---
+
+# Instalasi
+
+Pastikan Anda memiliki compiler C++17 (GCC/Clang/MSVC) dan Python 3.8+.
+
+```
+# Clone repository
+git clone https://github.com/eternalys/natumpy.git
+cd natumpy
+```
+```
+# Install (Compiling C++ Core secara otomatis)
+pip install .
+```
+# Memulai (Quick Start)
+## 1. Hello Resonance
+Melihat bagaimana Natumpy merespons sinyal input di level sinyal (Gelombang).
+```
+import natumpy as nt
+import numpy as np
+
+# Inisialisasi Engine 2048 Dimensi
+engine = nt.create_engine(2048)
+
+# Buat Sinyal Input (Vektor Kompleks)
+# Input Real (0.5) dan Imaginer (0.1)
+in_r = np.full(2048, 0.5)
+in_i = np.full(2048, 0.1)
+
+# Step Fisika (Berpikir 1 langkah)
+engine.step(in_r, in_i)
+
+# Intip isi otak (Layer 0)
+state = nt.get_state_complex(engine, layer_idx=0)
+print(f"Energi Otak: {np.mean(np.abs(state)):.4f}")
+```
+## 2. Membangun Chatbot (Reservoir Computing)
+Pola desain Natumpy memisahkan Otak (Reservoir) dan Mulut (Readout).
+ * Otak (C++) bertugas menghasilkan pola gelombang rumit di dimensi tinggi (Chaos).
+ * Mulut (Python) dilatih sederhana untuk menerjemahkan gelombang itu menjadi kata-kata.
+```
+import natumpy as nat
+import numpy as np
+
+# --- SETUP ---
+DIM = 2048
+otak = nat.ReservoirLayer(DIM)
+mulut = nat.ReadoutLayer(input_dim=DIM*4, output_dim=DIM*2) # 4 Layer Features
+tokenizer = nat.text.ResonantTokenizer(DIM)
+
+TEXT = "Natumpy adalah kecerdasan buatan masa depan yang efisien."
+
+# --- FASE 1: MENDENGAR (Rekam Gelombang Otak) ---
+X_states = []
+Y_targets = []
+
+# Encode Teks ke Gelombang
+inputs_r, inputs_i = tokenizer.encode(TEXT)
+targets_r, targets_i = tokenizer.encode(TEXT[1:] + " ") # Prediksi huruf selanjutnya
+
+print("Sedang membaca...")
+for t in range(len(inputs_r)):
+    # 1. Masukkan suara ke otak
+    state = otak.forward(inputs_r[t], inputs_i[t])
+    X_states.append(state)
+    
+    # 2. Siapkan target jawaban
+    target_vec = np.concatenate([targets_r[t], targets_i[t]])
+    Y_targets.append(target_vec)
+
+# --- FASE 2: BELAJAR BICARA (Linear Algebra) ---
+# Tidak ada epoch ribuan kali. Satu kali hitung (Exact Solution).
+mulut.fit(np.array(X_states), np.array(Y_targets))
+
+# --- FASE 3: GENERASI ---
+print("Output:", end=" ")
+# Seed awal
+pr, pi = tokenizer.encode("Natumpy")
+for i in range(len(pr)): otak.forward(pr[i], pi[i])
+
+# Biarkan dia bicara sendiri (Feedback Loop)
+curr_r, curr_i = pr[-1], pi[-1]
+for _ in range(50):
+    # Ambil state -> Terjemahkan lewat mulut -> Decode jadi huruf
+    state = otak.get_state()
+    pred_vec = mulut.predict(state)
+    
+    pred_r = pred_vec[:DIM]
+    pred_i = pred_vec[DIM:]
+    char = tokenizer.decode_sequence([pred_r], [pred_i])
+    
+    print(char, end="", flush=True)
+    
+    # Suara masuk kembali ke telinga (Auto-Regressive)
+    idx = tokenizer.decode(pred_r, pred_i)
+    next_r = tokenizer.embeddings_r[idx]
+    next_i = tokenizer.embeddings_i[idx]
+    otak.forward(next_r, next_i)
+```
+# Komponen Library
+ * natumpy.natcore: C++ Binding (Jantung Fisika). Jangan dimodifikasi kecuali Anda paham Aljabar Linear Kompleks.
+ * natumpy.layers: Abstraksi Python (ReservoirLayer, ReadoutLayer). Memudahkan pembuatan model.
+ * natumpy.text: Resonant Tokenizer. Mengubah teks menjadi gelombang tanpa kamus kata (Byte-level processing).
+ * natumpy.model: Wadah untuk menyusun arsitektur Deep Learning (Stacking Layers).
+# Kontribusi
+Proyek ini adalah eksperimen ilmiah terbuka. Kami mencari kontributor di bidang:
+ * Geometric Algebra: Untuk upgrade v9.0 (Multivectors / Clifford Algebra).
+ * Optimization: Implementasi CUDA/OpenMP untuk C++ Core agar mendukung jutaan neuron.
+ * Linguistics: Memperbaiki topologi semantik pada Tokenizer.
+# Lisensi
+MIT License
+Copyright (c) 2026 Eternals.
+
+

natumpy-1.0.0/natumpy/__init__.py

@@ -0,0 +1,37 @@
+import numpy as np
+from . import natcore
+from . import layers
+from . import model
+from . import utils
+
+__version__ = "8.0.0"
+
+NawaEngine = natcore.NawaSystem 
+
+Model = model.Model
+BaseLayer = layers.BaseLayer
+HolographicLayer = layers.HolographicLayer
+CausalLayer = layers.CausalLayer
+
+create_orthogonal_vector = utils.create_orthogonal_vector
+cosine_similarity = utils.cosine_similarity
+
+def create_engine(size):
+    return NawaEngine(int(size))
+
+def get_state_complex(engine, layer_idx=0):
+    real, imag = engine.get_state(int(layer_idx))
+    return real + 1j * imag
+
+def train_causality(engine, layer_idx, cause_state, effect_state):
+    c_r = np.real(cause_state).astype(np.float64)
+    c_i = np.imag(cause_state).astype(np.float64)
+    e_r = np.real(effect_state).astype(np.float64)
+    e_i = np.imag(effect_state).astype(np.float64)
+    
+    engine.learn(int(layer_idx), c_r, c_i, e_r, e_i)
+
+def think_next(engine, input_vec):
+    ir = np.real(input_vec).astype(np.float64)
+    ii = np.imag(input_vec).astype(np.float64)
+    engine.step(ir, ii)

natumpy-1.0.0/natumpy/layers.py

@@ -0,0 +1,59 @@
+import numpy as np
+from . import natcore
+
+class BaseLayer:
+    def __init__(self, dim, name="Layer"):
+        self.dim = dim
+        self.name = name
+        self.engine = natcore.NawaSystem(dim)
+        
+    def get_state(self):
+        r0, i0 = self.engine.get_state(0)
+        r4, i4 = self.engine.get_state(4)
+        return np.concatenate([r0, i0, r4, i4])
+
+    def step(self, r, i):
+        self.engine.step(r, i)
+
+class ReservoirLayer(BaseLayer):
+    def forward(self, input_r, input_i):
+        self.engine.step(input_r, input_i)
+        return self.get_state()
+
+    def save(self, filename):
+        self.engine.save(filename)
+        
+    def load(self, filename):
+        self.engine.load(filename)
+
+class ReadoutLayer:
+    def __init__(self, input_dim, output_dim, alpha=1.0):
+        self.input_dim = input_dim
+        self.output_dim = output_dim
+        self.alpha = alpha
+        self.W_out = None
+        
+    def fit(self, X_states, Y_targets):
+        print(f"   [Readout] Melatih W_out ({X_states.shape} >> {Y_targets.shape})...")
+        
+        A = X_states.T @ X_states + self.alpha * np.eye(X_states.shape[1])
+        B = X_states.T @ Y_targets
+        
+        try:
+            self.W_out = np.linalg.solve(A, B)
+            print("   [Readout] Solusi Exact ditemukan.")
+        except np.linalg.LinAlgError:
+            print("   [Readout] Matrix Singular. Menggunakan PseudoInverse.")
+            self.W_out = np.linalg.pinv(A) @ B
+            
+    def predict(self, state_vec):
+        if self.W_out is None:
+            raise ValueError("Readout belum dilatih, Panggil .fit() dulu.")
+        return state_vec @ self.W_out
+
+    def save(self, filename):
+        np.save(filename, self.W_out)
+        
+    def load(self, filename):
+        self.W_out = np.load(filename)
+

natumpy-1.0.0/natumpy/model.py

@@ -0,0 +1,26 @@
+import numpy as np
+
+class Model:
+    def __init__(self):
+        self.layers = {}
+        
+    def add_layer(self, name, layer):
+        self.layers[name] = layer
+        
+    def compile(self, beta=10.0, dt=0.2):
+        for name, layer in self.layers.items():
+            layer.set_config(beta=beta, dt=dt)
+            print(f"   [Natumpy] Layer '{name}' configured.")
+
+    def summary(self):
+        print("\n🧠 NATUMPY MODEL ARCHITECTURE")
+        print("="*50)
+        for name, layer in self.layers.items():
+            t_name = layer.__class__.__name__
+            dim = layer.dim
+            if hasattr(layer.engine, 'memory_count'):
+                mem = layer.engine.memory_count
+                rule = layer.engine.rule_count
+                print(f"   - {name:<12} | Type: {t_name:<16} | Dim: {dim} | Mem: {mem} | Rules: {rule}")
+        print("="*50 + "\n")
+

natumpy-1.0.0/natumpy/nat_bindings.cpp

@@ -0,0 +1,115 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include "nat_engine.hpp"
+
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#include <numpy/arrayobject.h>
+
+typedef struct {
+    PyObject_HEAD
+    NawaSystem* sys;
+} PyNawaSystem;
+
+static void PyNawaSystem_dealloc(PyNawaSystem* self) {
+    if (self->sys) delete self->sys;
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+static PyObject* PyNawaSystem_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
+    PyNawaSystem* self = (PyNawaSystem*)type->tp_alloc(type, 0);
+    int dim = 512;
+    if (self && PyArg_ParseTuple(args, "|i", &dim)) {
+        self->sys = new NawaSystem((size_t)dim);
+    }
+    return (PyObject*)self;
+}
+
+static bool py_to_vector(PyObject* obj, std::vector<Scalar>& vec) {
+    PyObject* arr = PyArray_ContiguousFromObject(obj, NPY_DOUBLE, 1, 1);
+    if (!arr) return false;
+    double* data = (double*)PyArray_DATA((PyArrayObject*)arr);
+    vec.assign(data, data + PyArray_DIM((PyArrayObject*)arr, 0));
+    Py_DECREF(arr);
+    return true;
+}
+
+static PyObject* PyNawaSystem_step(PyNawaSystem* self, PyObject* args) {
+    PyObject *ir, *ii;
+    if (!PyArg_ParseTuple(args, "OO", &ir, &ii)) return NULL;
+    std::vector<Scalar> vr, vi;
+    if (!py_to_vector(ir, vr) || !py_to_vector(ii, vi)) return NULL;
+    
+    self->sys->step(vr, vi);
+    Py_RETURN_NONE;
+}
+
+static PyObject* PyNawaSystem_save(PyNawaSystem* self, PyObject* args) {
+    const char* f; if(!PyArg_ParseTuple(args, "s", &f)) return NULL;
+    self->sys->save(std::string(f)); Py_RETURN_NONE;
+}
+
+static PyObject* PyNawaSystem_load(PyNawaSystem* self, PyObject* args) {
+    const char* f; if(!PyArg_ParseTuple(args, "s", &f)) return NULL;
+    self->sys->load(std::string(f)); Py_RETURN_NONE;
+}
+
+static PyObject* PyNawaSystem_get_state(PyNawaSystem* self, PyObject* args) {
+    int layer;
+    if (!PyArg_ParseTuple(args, "i", &layer)) return NULL;
+    
+    auto r = self->sys->get_layer_r(layer);
+    auto i = self->sys->get_layer_i(layer);
+    
+    npy_intp dims[1] = { (npy_intp)r.size() };
+    PyObject* ar = PyArray_SimpleNewFromData(1, dims, NPY_DOUBLE, r.data()); 
+    PyObject* ai = PyArray_SimpleNewFromData(1, dims, NPY_DOUBLE, i.data());
+    
+    PyObject* safe_r = PyArray_NewCopy((PyArrayObject*)ar, NPY_ANYORDER);
+    PyObject* safe_i = PyArray_NewCopy((PyArrayObject*)ai, NPY_ANYORDER);
+    Py_DECREF(ar); Py_DECREF(ai);
+    
+    return Py_BuildValue("(OO)", safe_r, safe_i);
+}
+
+static PyObject* PyNawaSystem_learn(PyNawaSystem* self, PyObject* args) {
+    int layer;
+    PyObject *ir, *ii, *or_, *oi;
+    if (!PyArg_ParseTuple(args, "iOOOO", &layer, &ir, &ii, &or_, &oi)) return NULL;
+    std::vector<Scalar> vir, vii, vor, voi;
+    if(!py_to_vector(ir, vir) || !py_to_vector(ii, vii) || !py_to_vector(or_, vor) || !py_to_vector(oi, voi)) return NULL;
+    
+    self->sys->learn(layer, vir, vii, vor, voi);
+    
+    Py_RETURN_NONE;
+}
+
+static PyMethodDef PyNawaSystem_methods[] = {
+    {"step", (PyCFunction)PyNawaSystem_step, METH_VARARGS, ""},
+    {"save", (PyCFunction)PyNawaSystem_save, METH_VARARGS, ""},
+    {"load", (PyCFunction)PyNawaSystem_load, METH_VARARGS, ""},
+    {"get_state", (PyCFunction)PyNawaSystem_get_state, METH_VARARGS, ""},
+    {"learn", (PyCFunction)PyNawaSystem_learn, METH_VARARGS, ""},
+    {NULL}
+};
+
+static PyTypeObject PyNawaSystemType = {
+    PyVarObject_HEAD_INIT(NULL, 0) 
+    .tp_name = "natcore.NawaSystem", 
+    .tp_basicsize = sizeof(PyNawaSystem),
+    .tp_dealloc = (destructor)PyNawaSystem_dealloc, 
+    .tp_flags = Py_TPFLAGS_DEFAULT,
+    .tp_methods = PyNawaSystem_methods, 
+    .tp_new = PyNawaSystem_new,
+};
+
+static struct PyModuleDef natcoremodule = { PyModuleDef_HEAD_INIT, "natcore", "Nawa Harmonic Engine", -1, NULL };
+PyMODINIT_FUNC PyInit_natcore(void) {
+    import_array();
+    if (PyType_Ready(&PyNawaSystemType) < 0) return NULL;
+    PyObject* m = PyModule_Create(&natcoremodule);
+    if (!m) return NULL;
+    Py_INCREF(&PyNawaSystemType);
+    PyModule_AddObject(m, "NawaSystem", (PyObject*)&PyNawaSystemType);
+    return m;
+}
+

natumpy-1.0.0/natumpy/nat_engine.cpp

@@ -0,0 +1,213 @@
+#include "nat_engine.hpp"
+#include <cmath>
+#include <algorithm>
+#include <numeric>
+#include <vector>
+#include <random>
+#include <iostream>
+#include <fstream>
+
+inline Scalar sigmoid(Scalar x) { return 1.0 / (1.0 + std::exp(-x)); }
+inline Scalar tanh_activation(Scalar x) { return std::tanh(x); }
+
+void NawaMemory::init(size_t dimension) {
+    dim = dimension;
+    W_recurrent_r.resize(dim * dim, 0.0); 
+    W_recurrent_i.resize(dim * dim, 0.0);
+    
+    W_gate_r.resize(dim); W_gate_i.resize(dim);
+    W_input_r.resize(dim); W_input_i.resize(dim);
+    W_feedback_r.resize(dim); W_feedback_i.resize(dim);
+}
+
+void NawaMemory::save(std::ostream& out) {
+    out.write((char*)&dim, sizeof(size_t));
+    out.write((char*)W_recurrent_r.data(), dim*dim*sizeof(Scalar));
+    out.write((char*)W_recurrent_i.data(), dim*dim*sizeof(Scalar));
+    out.write((char*)W_gate_r.data(), dim*sizeof(Scalar)); out.write((char*)W_gate_i.data(), dim*sizeof(Scalar));
+    out.write((char*)W_input_r.data(), dim*sizeof(Scalar)); out.write((char*)W_input_i.data(), dim*sizeof(Scalar));
+    out.write((char*)W_feedback_r.data(), dim*sizeof(Scalar)); out.write((char*)W_feedback_i.data(), dim*sizeof(Scalar));
+}
+
+void NawaMemory::load(std::istream& in) {
+    size_t loaded_dim;
+    in.read((char*)&loaded_dim, sizeof(size_t));
+    if(loaded_dim != dim) return;
+    in.read((char*)W_recurrent_r.data(), dim*dim*sizeof(Scalar));
+    in.read((char*)W_recurrent_i.data(), dim*dim*sizeof(Scalar));
+    in.read((char*)W_gate_r.data(), dim*sizeof(Scalar)); in.read((char*)W_gate_i.data(), dim*sizeof(Scalar));
+    in.read((char*)W_input_r.data(), dim*sizeof(Scalar)); in.read((char*)W_input_i.data(), dim*sizeof(Scalar));
+    in.read((char*)W_feedback_r.data(), dim*sizeof(Scalar)); in.read((char*)W_feedback_i.data(), dim*sizeof(Scalar));
+}
+
+NawaSphere::NawaSphere(size_t dimension, int id, int ratio) {
+    layer_id = id; time_ratio = ratio;
+    state.resize(dimension); memory.init(dimension);
+    buf_input_r.resize(dimension, 0.0); buf_input_i.resize(dimension, 0.0);
+    buf_feedback_r.resize(dimension, 0.0); buf_feedback_i.resize(dimension, 0.0);
+}
+
+void NawaSphere::init_weights(int seed) {
+    std::mt19937 gen(seed);
+    std::normal_distribution<Scalar> d(0.0, 0.05);
+
+    for(size_t i=0; i<state.size; ++i) {
+        for(size_t j=0; j<state.size; ++j) {
+            size_t idx = i * state.size + j;
+            if (i == j) {
+                memory.W_recurrent_r[idx] = 1.0;
+                memory.W_recurrent_i[idx] = 0.0;
+            } else {
+                memory.W_recurrent_r[idx] = d(gen) * 0.1;
+                memory.W_recurrent_i[idx] = d(gen) * 0.1;
+            }
+        }
+    }
+
+    for(size_t i=0; i<state.size; ++i) {
+        memory.W_gate_r[i] = d(gen) + 1.0;
+        memory.W_gate_i[i] = d(gen) * 0.05;
+        
+        memory.W_input_r[i] = 1.0 + d(gen)*0.1; 
+        memory.W_input_i[i] = d(gen)*0.1;
+        
+        memory.W_feedback_r[i] = 0.3 + d(gen)*0.1; memory.W_feedback_i[i] = d(gen)*0.1;
+    }
+}
+
+void NawaSphere::set_input(const std::vector<Scalar>& r, const std::vector<Scalar>& i) {
+    if(r.size()==state.size) { buf_input_r=r; buf_input_i=i; }
+}
+void NawaSphere::set_feedback(const std::vector<Scalar>& r, const std::vector<Scalar>& i) {
+    if(r.size()==state.size) { buf_feedback_r=r; buf_feedback_i=i; }
+}
+
+void NawaSphere::step_integrate() {
+    size_t N = state.size;
+    std::vector<Scalar> next_r(N), next_i(N);
+    
+    for(size_t i=0; i<N; ++i) {
+        Scalar sum_r = 0.0;
+        Scalar sum_i = 0.0;
+        for(size_t j=0; j<N; ++j) {
+            size_t idx = i * N + j;
+            Scalar w_r = memory.W_recurrent_r[idx];
+            Scalar w_i = memory.W_recurrent_i[idx];
+            Scalar s_r = state.q_r[j];
+            Scalar s_i = state.q_i[j];
+            
+            sum_r += (w_r * s_r - w_i * s_i);
+            sum_i += (w_r * s_i + w_i * s_r);
+        }
+        
+        Scalar in_r = buf_input_r[i]*memory.W_input_r[i] - buf_input_i[i]*memory.W_input_i[i];
+        Scalar in_i = buf_input_r[i]*memory.W_input_i[i] + buf_input_i[i]*memory.W_input_r[i];
+        
+        Scalar fb_r = buf_feedback_r[i]*memory.W_feedback_r[i] - buf_feedback_i[i]*memory.W_feedback_i[i];
+        Scalar fb_i = buf_feedback_r[i]*memory.W_feedback_i[i] + buf_feedback_i[i]*memory.W_feedback_r[i];
+        
+        Scalar total_r = sum_r + in_r + fb_r;
+        Scalar total_i = sum_i + in_i + fb_i;
+        
+        Scalar gate = sigmoid((memory.W_gate_r[i]*total_r - memory.W_gate_i[i]*total_i));
+        
+        next_r[i] = (1.0 - gate) * state.q_r[i] + gate * total_r;
+        next_i[i] = (1.0 - gate) * state.q_i[i] + gate * total_i;
+    }
+    
+    state.q_r = next_r;
+    state.q_i = next_i;
+    
+    normalize(); 
+}
+
+void NawaSphere::normalize() {
+    for(size_t i=0; i<state.size; ++i) {
+        Scalar mag = std::sqrt(state.q_r[i]*state.q_r[i] + state.q_i[i]*state.q_i[i]);
+        if (mag > 1e-9) {
+            Scalar new_mag = std::tanh(mag); 
+            Scalar scale = new_mag / mag;
+            state.q_r[i] *= scale;
+            state.q_i[i] *= scale;
+        } else {
+            state.q_r[i] = 0.0; state.q_i[i] = 0.0;
+        }
+    }
+}
+
+NawaSystem::NawaSystem(size_t dimension) {
+    base_dim = dimension;
+    global_tick = 0;
+    int ratio = 1;
+    for(int i=0; i<NAWA_LAYERS; ++i) {
+        spheres.push_back(std::make_unique<NawaSphere>(dimension, i, ratio));
+        spheres.back()->init_weights(42+i);
+        ratio *= 2; 
+    }
+}
+
+void NawaSystem::step(const std::vector<Scalar>& ir, const std::vector<Scalar>& ii) {
+    global_tick++;
+    spheres[0]->set_input(ir, ii);
+    for(int i=0; i<NAWA_LAYERS; ++i) {
+        if(global_tick % spheres[i]->time_ratio == 0) {
+            if(i > 0) spheres[i]->set_input(spheres[i-1]->state.q_r, spheres[i-1]->state.q_i);
+            if(i < NAWA_LAYERS-1) spheres[i]->set_feedback(spheres[i+1]->state.q_r, spheres[i+1]->state.q_i);
+            spheres[i]->step_integrate();
+        }
+    }
+}
+
+void NawaSystem::save(const std::string& filename) {
+    std::ofstream out(filename, std::ios::binary);
+    if(out) for(auto& s : spheres) s->memory.save(out);
+}
+void NawaSystem::load(const std::string& filename) {
+    std::ifstream in(filename, std::ios::binary);
+    if(in) for(auto& s : spheres) s->memory.load(in);
+}
+std::vector<Scalar> NawaSystem::get_layer_r(int idx) {
+    if(idx>=0 && idx<NAWA_LAYERS) return spheres[idx]->state.q_r;
+    return {};
+}
+std::vector<Scalar> NawaSystem::get_layer_i(int idx) {
+    if(idx>=0 && idx<NAWA_LAYERS) return spheres[idx]->state.q_i;
+    return {};
+}
+
+void NawaSystem::learn(int idx, 
+                       const std::vector<Scalar>& in_r, const std::vector<Scalar>& in_i,
+                       const std::vector<Scalar>& error_r, const std::vector<Scalar>& error_i) {
+    if (idx < 0 || idx >= NAWA_LAYERS) return;
+    
+    NawaSphere* s = spheres[idx].get();
+    size_t N = s->state.size;
+    Scalar lr = 0.05; 
+    
+    for(size_t i=0; i<N; ++i) {
+        Scalar err_real = error_r[i];
+        Scalar err_imag = error_i[i];
+        
+        for(size_t j=0; j<N; ++j) {
+            size_t widx = i * N + j;
+            Scalar inp_real = in_r[j]; 
+            Scalar inp_imag = in_i[j];
+            
+            Scalar grad_r = err_real * inp_real + err_imag * inp_imag;
+            Scalar grad_i = err_imag * inp_real - err_real * inp_imag;
+            
+            s->memory.W_recurrent_r[widx] += lr * grad_r;
+            s->memory.W_recurrent_i[widx] += lr * grad_i;
+            
+            s->memory.W_recurrent_r[widx] *= 0.9999; 
+            s->memory.W_recurrent_i[widx] *= 0.9999;
+        }
+
+        Scalar grad_in_r = err_real * in_r[i] + err_imag * in_i[i];
+        Scalar grad_in_i = err_imag * in_r[i] - err_real * in_i[i];
+        
+        s->memory.W_input_r[i] += lr * grad_in_r;
+        s->memory.W_input_i[i] += lr * grad_in_i;
+    }
+}
+

natumpy-1.0.0/natumpy/nat_engine.hpp

@@ -0,0 +1,78 @@
+#pragma once
+#include <vector>
+#include <cmath>
+#include <complex>
+#include <algorithm>
+#include <iostream>
+#include <fstream>
+#include <random>
+#include <memory>
+
+#define NAWA_LAYERS 9 
+
+using Scalar = double;
+
+struct NawaState {
+    size_t size = 0;
+    std::vector<Scalar> q_r; 
+    std::vector<Scalar> q_i;
+
+    void resize(size_t n) {
+        size = n;
+        q_r.resize(n, 0.0); q_i.resize(n, 0.0);
+    }
+};
+
+struct NawaMemory {
+    size_t dim = 0;
+    
+    std::vector<Scalar> W_recurrent_r;
+    std::vector<Scalar> W_recurrent_i;
+    
+    std::vector<Scalar> W_input_r, W_input_i;
+    std::vector<Scalar> W_gate_r, W_gate_i;
+    std::vector<Scalar> W_feedback_r, W_feedback_i;
+
+    void init(size_t dimension);
+    void save(std::ostream& out);
+    void load(std::istream& in);
+};
+
+class NawaSphere {
+public:
+    int layer_id;
+    int time_ratio;
+    
+    NawaState state;
+    NawaMemory memory;
+    
+    std::vector<Scalar> buf_input_r, buf_input_i;
+    std::vector<Scalar> buf_feedback_r, buf_feedback_i;
+
+    NawaSphere(size_t dimension, int id, int ratio);
+
+    void init_weights(int seed);
+    void step_integrate();
+    void set_input(const std::vector<Scalar>& r, const std::vector<Scalar>& i);
+    void set_feedback(const std::vector<Scalar>& r, const std::vector<Scalar>& i);
+    void normalize();
+};
+
+class NawaSystem {
+private:
+    std::vector<std::unique_ptr<NawaSphere>> spheres;
+    size_t global_tick = 0;
+    size_t base_dim = 0;
+
+public:
+    NawaSystem(size_t dimension);
+    void step(const std::vector<Scalar>& input_r, const std::vector<Scalar>& input_i);
+    void save(const std::string& filename);
+    void load(const std::string& filename);
+    std::vector<Scalar> get_layer_r(int idx);
+    std::vector<Scalar> get_layer_i(int idx);
+    void learn(int layer_idx, 
+               const std::vector<Scalar>& in_r, const std::vector<Scalar>& in_i,
+               const std::vector<Scalar>& out_r, const std::vector<Scalar>& out_i);
+};
+

natumpy-1.0.0/natumpy/text.py

@@ -0,0 +1,63 @@
+import numpy as np
+import pickle
+import os
+
+class ResonantTokenizer:
+    def __init__(self, dim=128):
+        self.dim = dim
+        self.vocab_size = 256
+        
+        rng = np.random.default_rng(42)
+        
+        r = rng.normal(0, 1, (self.vocab_size, dim))
+        i = rng.normal(0, 1, (self.vocab_size, dim))
+        
+        mag = np.sqrt(r**2 + i**2) + 1e-9
+        self.embeddings_r = r / mag
+        self.embeddings_i = i / mag
+        
+    def encode(self, text):
+        if isinstance(text, str):
+            bytes_data = text.encode('utf-8')
+        else:
+            bytes_data = text
+            
+        indices = np.array(list(bytes_data), dtype=int)
+        
+        seq_r = self.embeddings_r[indices]
+        seq_i = self.embeddings_i[indices]
+        
+        return seq_r, seq_i
+
+    def decode(self, vec_r, vec_i):
+        scores = (vec_r @ self.embeddings_r.T) + (vec_i @ self.embeddings_i.T)
+        best_idx = np.argmax(scores)
+        return best_idx
+
+    def decode_sequence(self, seq_r, seq_i):
+        bytes_list = []
+        for i in range(len(seq_r)):
+            idx = self.decode(seq_r[i], seq_i[i])
+            bytes_list.append(idx)
+        
+        try:
+            return bytes(bytes_list).decode('utf-8', errors='replace')
+        except:
+            return "<binary>"
+
+    def save(self, filename):
+        with open(filename, 'wb') as f:
+            pickle.dump({
+                'dim': self.dim,
+                'er': self.embeddings_r,
+                'ei': self.embeddings_i
+            }, f)
+            
+    def load(self, filename):
+        if not os.path.exists(filename): return
+        with open(filename, 'rb') as f:
+            data = pickle.load(f)
+            self.dim = data['dim']
+            self.embeddings_r = data['er']
+            self.embeddings_i = data['ei']
+

natumpy-1.0.0/natumpy/utils.py

@@ -0,0 +1,13 @@
+import numpy as np
+
+def create_orthogonal_vector(dim, seed):
+    np.random.seed(seed)
+    r = np.random.randn(dim)
+    i = np.random.randn(dim)
+    mag = np.sqrt(r**2 + i**2) + 1e-9
+    return (r/mag) + 1j * (i/mag)
+
+def cosine_similarity(v1, v2):
+    dot = np.real(np.sum(v1 * np.conj(v2)))
+    return dot
+

natumpy-1.0.0/natumpy.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: natumpy
+Version: 1.0.0
+Summary: Nawa Causal Engine: Complex-Valued Reservoir Computing based on Harmonic Resonance.
+Home-page: https://github.com/arclaav/natumpy
+Author: Eternals
+Author-email: admin@defacer.cloud-ip.cc
+Keywords: ai,reservoir-computing,esn,complex-valued,neural-network,c++,nawa
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+    Natumpy is a deterministic AI engine that uses complex-valued signals (phase & amplitude) 
+    to model information as interference patterns, distinct from probabilistic Transformers.
+    Powered by a high-performance C++ backend implementing the Nawa (9-Sphere) topology.
+    

natumpy-1.0.0/natumpy.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+natumpy/__init__.py
+natumpy/layers.py
+natumpy/model.py
+natumpy/nat_bindings.cpp
+natumpy/nat_engine.cpp
+natumpy/nat_engine.hpp
+natumpy/text.py
+natumpy/utils.py
+natumpy.egg-info/PKG-INFO
+natumpy.egg-info/SOURCES.txt
+natumpy.egg-info/dependency_links.txt
+natumpy.egg-info/requires.txt
+natumpy.egg-info/top_level.txt

natumpy-1.0.0/natumpy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

natumpy-1.0.0/natumpy.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy>=1.20.0

natumpy-1.0.0/natumpy.egg-info/top_level.txt

@@ -0,0 +1 @@
+natumpy

natumpy-1.0.0/pyproject.toml

@@ -0,0 +1,4 @@
+[build-system]
+requires = ["setuptools>=42", "wheel", "numpy>=1.20.0"]
+build-backend = "setuptools.build_meta"
+

natumpy-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

natumpy-1.0.0/setup.py

@@ -0,0 +1,55 @@
+from setuptools import setup, Extension, find_packages
+import sys
+
+try:
+    import numpy
+    np_include = [numpy.get_include()]
+except ImportError:
+    np_include = []
+
+extra_compile_args = ['-std=c++17', '-O3', '-Wall', '-march=native', '-ffast-math']
+
+if sys.platform == 'darwin':
+    extra_compile_args.append('-stdlib=libc++')
+
+module = Extension(
+    'natumpy.natcore',
+    sources=[
+        'natumpy/nat_bindings.cpp',
+        'natumpy/nat_engine.cpp'
+    ],
+    depends=['natumpy/nat_engine.hpp'],
+    include_dirs=np_include,
+    extra_compile_args=extra_compile_args,
+    language='c++'
+)
+
+setup(
+    name='natumpy',
+    version='1.0.0',
+    packages=find_packages(),
+    ext_modules=[module],
+    python_requires='>=3.8',
+    install_requires=['numpy>=1.20.0'],
+    
+    description='Nawa Causal Engine: Complex-Valued Reservoir Computing based on Harmonic Resonance.',
+    long_description="""
+    Natumpy is a deterministic AI engine that uses complex-valued signals (phase & amplitude) 
+    to model information as interference patterns, distinct from probabilistic Transformers.
+    Powered by a high-performance C++ backend implementing the Nawa (9-Sphere) topology.
+    """,
+    author='Eternals',
+    author_email='admin@defacer.cloud-ip.cc',
+    url='https://github.com/arclaav/natumpy',
+    
+    keywords=['ai', 'reservoir-computing', 'esn', 'complex-valued', 'neural-network', 'c++', 'nawa'],
+    classifiers=[
+        'Development Status :: 4 - Beta',
+        'Intended Audience :: Science/Research',
+        'Topic :: Scientific/Engineering :: Artificial Intelligence',
+        'Programming Language :: C++',
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+)