sigma-c-framework 1.0.0__tar.gz

sigma_c_framework-1.0.0/DOCUMENTATION.md

@@ -0,0 +1,155 @@
+# Sigma-C Framework Documentation / Dokumentation
+
+**Version:** 1.0.0  
+**Date:** November 2025  
+**Copyright:** (c) 2025 ForgottenForge.xyz
+
+---
+
+## 🇬🇧 English
+
+### 1. Introduction
+**Sigma-C Framework** is a high-performance framework for detecting **critical phase transitions** in complex systems. Unlike traditional metrics (like standard deviation or simple thresholds), Sigma-C uses **Critical Susceptibility ($\chi$)** theory to identify the precise scale or parameter value where a system undergoes a fundamental structural change.
+
+**Why is it superior?**
+*   **Sensitivity:** Detects precursors to instability (crashes, failures) *before* they happen.
+*   **Universality:** The same math works for Quantum Noise, GPU Thrashing, Financial Crashes, and Seismic Activity.
+*   **Robustness:** Uses bootstrap and permutation testing to filter out false positives.
+
+### 2. Installation
+
+**Prerequisites:** Python 3.8+, C++17 compiler (MSVC, GCC, or Clang).
+
+#### Windows
+```powershell
+# 1. Clone the repository
+git clone https://github.com/forgottenforge/sigmacore.git
+cd sigmacore/sigma_c_framework
+
+# 2. Install dependencies and build C++ core
+pip install .
+```
+
+#### Linux / macOS
+```bash
+# 1. Clone the repository
+git clone https://github.com/forgottenforge/sigmacore.git
+cd sigmacore/sigma_c_framework
+
+# 2. Install dependencies and build C++ core
+pip install .
+```
+
+### 3. Integration
+
+#### Python (Recommended)
+The `Universe` class is your single entry point.
+
+```python
+from sigma_c import Universe
+
+# Initialize an adapter
+gpu = Universe.gpu()
+
+# Run analysis
+result = gpu.auto_tune(alpha_levels=[0.1, 0.5, 0.9])
+print(f"Critical Point: {result['sigma_c']}")
+```
+
+#### C++ (High Performance)
+Link against `sigma_c_core.lib` / `libsigma_c_core.so`.
+
+```cpp
+#include <sigma_c/susceptibility.hpp>
+
+std::vector<double> x = { ... };
+std::vector<double> y = { ... };
+auto result = sigma_c::compute_susceptibility(x, y);
+std::cout << "Sigma-C: " << result.sigma_c << std::endl;
+```
+
+### 4. Domain Examples
+
+See the `examples_v4/` directory for runnable scripts.
+
+*   **Quantum:** `demo_quantum.py` - Detects when noise breaks Grover's algorithm.
+*   **Finance:** `demo_finance.py` - Identifies market regimes and crash risks.
+*   **GPU:** `demo_gpu.py` - Auto-tunes kernels to avoid cache thrashing.
+*   **Climate:** `demo_climate.py` - Finds characteristic scales of weather systems.
+*   **Seismic:** `demo_seismic.py` - Detects critical stress correlation lengths.
+*   **Magnetic:** `demo_magnetic.py` - Finds Curie temperature in 2D Ising model.
+
+---
+
+## 🇩🇪 Deutsch
+
+### 1. Einführung
+**Sigma-C Framework** ist ein Hochleistungs-Framework zur Erkennung von **kritischen Phasenübergängen** in komplexen Systemen. Im Gegensatz zu herkömmlichen Metriken (wie Standardabweichung) nutzt Sigma-C die Theorie der **Kritischen Suszeptibilität ($\chi$)**, um den genauen Punkt zu identifizieren, an dem sich die Struktur eines Systems grundlegend ändert.
+
+**Warum ist es überlegen?**
+*   **Sensitivität:** Erkennt Vorboten von Instabilität (Abstürze, Ausfälle), *bevor* sie eintreten.
+*   **Universalität:** Die gleiche Mathematik funktioniert für Quantenrauschen, GPU-Thrashing, Finanzcrashs und Erdbeben.
+*   **Robustheit:** Nutzt Bootstrap- und Permutationstests, um Fehlalarme auszuschließen.
+
+### 2. Installation
+
+**Voraussetzungen:** Python 3.8+, C++17 Compiler.
+
+#### Windows
+```powershell
+# 1. Repository klonen
+git clone https://github.com/forgottenforge/sigmacore.git
+cd sigmacore/sigma_c_framework
+
+# 2. Installieren
+pip install .
+```
+
+#### Linux / macOS
+```bash
+# 1. Repository klonen
+git clone https://github.com/forgottenforge/sigmacore.git
+cd sigmacore/sigma_c_framework
+
+# 2. Installieren
+pip install .
+```
+
+### 3. Integration
+
+#### Python (Empfohlen)
+Die `Universe`-Klasse ist der zentrale Einstiegspunkt.
+
+```python
+from sigma_c import Universe
+
+# Adapter initialisieren
+gpu = Universe.gpu()
+
+# Analyse starten
+result = gpu.auto_tune(alpha_levels=[0.1, 0.5, 0.9])
+print(f"Kritischer Punkt: {result['sigma_c']}")
+```
+
+#### C++ (Hochleistung)
+Gegen `sigma_c_core.lib` / `libsigma_c_core.so` linken.
+
+```cpp
+#include <sigma_c/susceptibility.hpp>
+
+std::vector<double> x = { ... };
+std::vector<double> y = { ... };
+auto result = sigma_c::compute_susceptibility(x, y);
+std::cout << "Sigma-C: " << result.sigma_c << std::endl;
+```
+
+### 4. Anwendungsbeispiele
+
+Siehe `examples_v4/` für ausführbare Skripte.
+
+*   **Quantum:** `demo_quantum.py` - Erkennt, wann Rauschen den Grover-Algorithmus bricht.
+*   **Finance:** `demo_finance.py` - Identifiziert Marktregimes und Crash-Risiken.
+*   **GPU:** `demo_gpu.py` - Optimiert Kernel, um Cache-Thrashing zu vermeiden.
+*   **Climate:** `demo_climate.py` - Findet charakteristische Skalen von Wettersystemen.
+*   **Seismic:** `demo_seismic.py` - Erkennt kritische Spannungskorrelationen.
+*   **Magnetic:** `demo_magnetic.py` - Findet Curie-Temperatur im 2D-Ising-Modell.

sigma_c_framework-1.0.0/LICENSE.txt

@@ -0,0 +1,29 @@
+# License Notice
+
+This software is licensed under a **dual-license model**:
+
+1. **For Open Source and Non-Commercial Use**  
+   - Licensed under the **GNU Affero General Public License v3.0 (AGPL-3.0)**.  
+   - You may use, modify, and distribute this software **provided that any derivative works are also licensed under the AGPL-3.0**.  
+   - See `LICENSE-AGPL.txt` for full license terms.
+
+2. **For Commercial Use**  
+   - Companies, organizations, and other commercial entities **must obtain a commercial license**.  
+   - The commercial license allows proprietary use without the copyleft requirements of the AGPL.  
+   - See `LICENSE-COMMERCIAL.txt` for details and contact information.
+
+By using this software, you agree to these terms.  
+For commercial licensing inquiries, please visit: **[www.theqa.space]**
+
+---
+
+## Summary of Key Terms
+
+| License Type | Permitted Uses | Restrictions |
+|---------------|----------------|---------------|
+| **AGPL-3.0** (for open-source / non-commercial use) | Free use, modification, redistribution under AGPL | Must disclose source code of modified versions and networked services |
+| **Commercial License** (for companies) | Proprietary use, closed-source integration, internal business use | Requires commercial agreement, no resale without consent |
+
+For full details, see:
+- `LICENSE-AGPL.txt`
+- `LICENSE-COMMERCIAL.txt`

sigma_c_framework-1.0.0/MANIFEST.in

@@ -0,0 +1,23 @@
+include README.md
+include LICENSE.txt
+include license_AGPL.txt
+include license_COMMERCIAL.txt
+include DOCUMENTATION.md
+include QUICKSTART.md
+include pyproject.toml
+
+# Include C++ source and headers
+recursive-include sigma_c_core/src *.cpp *.hpp
+recursive-include sigma_c_core/include *.hpp
+
+# Include Python package
+recursive-include sigma_c *.py
+
+# Include examples (only v4)
+recursive-include examples_v4 *.py
+
+# Exclude unwanted files
+global-exclude __pycache__
+global-exclude *.py[cod]
+global-exclude *.so
+global-exclude .DS_Store

sigma_c_framework-1.0.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: sigma-c-framework
+Version: 1.0.0
+Summary: Critical Susceptibility Framework for Quantum, GPU, Financial, Climate, Seismic, and Magnetic analysis
+Author-email: ForgottenForge <nfo@forgottenforge.xyz>
+License: AGPL-3.0-or-later OR Commercial
+Project-URL: Homepage, https://github.com/forgottenforge/sigmacore
+Project-URL: Documentation, https://github.com/forgottenforge/sigmacore/blob/main/DOCUMENTATION.md
+Project-URL: Repository, https://github.com/forgottenforge/sigmacore
+Project-URL: Issues, https://github.com/forgottenforge/sigmacore/issues
+Keywords: critical-phenomena,phase-transitions,quantum-computing,gpu-optimization,financial-analysis,climate-science,seismology,susceptibility
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: C++
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+License-File: license_AGPL.txt
+License-File: license_COMMERCIAL.txt
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: tqdm>=4.60.0
+Requires-Dist: matplotlib>=3.4.0
+Requires-Dist: seaborn>=0.11.0
+Requires-Dist: requests>=2.25.0
+Requires-Dist: yfinance>=0.1.63
+Provides-Extra: quantum
+Requires-Dist: amazon-braket-sdk>=1.9.0; extra == "quantum"
+Provides-Extra: gpu
+Requires-Dist: cupy>=9.0.0; extra == "gpu"
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Requires-Dist: mypy>=0.900; extra == "dev"
+Dynamic: license-file
+
+[![PyPI version](https://badge.fury.io/py/sigma-c-framework.svg)](https://badge.fury.io/py/sigma-c-framework)
+[![License: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+# Sigma-C Framework v1.0.0
+
+**Copyright (c) 2025 ForgottenForge.xyz**
+
+**Critical Susceptibility Framework** for Quantum, GPU, Financial, Climate, Seismic, and Magnetic analysis.
+
+## 🚀 Quick Start
+
+```bash
+# Install the package
+pip install sigma-c-framework
+
+# Run examples
+python -m sigma_c.examples.demo_quantum
+```
+
+Or clone and install from source:
+```bash
+git clone https://github.com/forgottenforge/sigmacore.git
+cd sigmacore/sigma_c_framework
+pip install .
+```
+
+## 🎯 What is Sigma-C?
+
+Sigma-C detects **critical phase transitions** in complex systems using Critical Susceptibility (χ) theory. Unlike traditional metrics, it identifies the precise scale where systems undergo fundamental structural changes.
+
+**Use Cases:**
+- 🔬 **Quantum Computing**: Find noise thresholds that break quantum algorithms
+- 🎮 **GPU Optimization**: Auto-tune kernels to avoid cache thrashing
+- 💰 **Finance**: Predict market crashes before they happen
+- 🌍 **Climate Science**: Identify characteristic scales of weather systems
+- 🌋 **Seismology**: Detect critical stress states in earthquake catalogs
+- 🧲 **Magnetism**: Analyze phase transitions (Curie temperature)
+
+## 📦 Features
+
+- **6 Domain Adapters** ready for production use
+- **High-Performance C++ Core** with Python bindings
+- **Statistical Robustness** via bootstrap and permutation tests
+- **Comprehensive Documentation** in English and German
+- **Dual License**: AGPL-3.0 or Commercial
+
+## 📚 Documentation
+
+- **Quick Start**: See [QUICKSTART.md](QUICKSTART.md) (5 minutes)
+- **Full Documentation**: See [DOCUMENTATION.md](DOCUMENTATION.md) (English + German)
+- **Release Guide**: See [RELEASE.md](RELEASE.md) (for contributors)
+- **Changelog**: See [CHANGELOG.md](CHANGELOG.md)
+
+## 💡 Example
+
+```python
+from sigma_c import Universe
+
+# Detect GPU performance critical point
+gpu = Universe.gpu()
+result = gpu.auto_tune(alpha_levels=[0.1, 0.5, 0.9])
+
+print(f"Critical threshold: {result['sigma_c']:.3f}")
+print(f"Stability score: {result['statistics']['kappa']:.2f}")
+```
+
+## 📄 License
+
+Dual-licensed under AGPL-3.0 or Commercial License.
+
+- **Open Source**: See [license_AGPL.txt](license_AGPL.txt)
+- **Commercial**: Contact nfo@forgottenforge.xyz
+
+For commercial licensing without AGPL-3.0 obligations, contact: **nfo@forgottenforge.xyz**
+
+## 🤝 Contributing
+
+Contributions are welcome! Please read our contributing guidelines and submit pull requests.
+
+## 📧 Contact
+
+- **Email**: nfo@forgottenforge.xyz
+- **GitHub**: [github.com/forgottenforge/sigmacore](https://github.com/forgottenforge/sigmacore)
+- **Issues**: [github.com/forgottenforge/sigmacore/issues](https://github.com/forgottenforge/sigmacore/issues)
+
+---
+
+**Made with ❤️ by ForgottenForge**

sigma_c_framework-1.0.0/QUICKSTART.md

@@ -0,0 +1,162 @@
+# Sigma-C Framework - Quick Start Guide
+
+**Version 1.0.0** | **Copyright (c) 2025 ForgottenForge.xyz**
+
+## For Developers: Getting Started in 5 Minutes
+
+### 1. Installation
+
+```bash
+# Clone and install
+git clone https://github.com/forgottenforge/sigmacore.git
+cd sigmacore/sigma_c_framework
+pip install .
+```
+
+### 2. Your First Analysis
+
+```python
+from sigma_c import Universe
+
+# Example: Detect GPU performance critical point
+gpu = Universe.gpu()
+result = gpu.auto_tune(alpha_levels=[0.1, 0.3, 0.5, 0.7, 0.9])
+
+print(f"Critical threshold: {result['sigma_c']:.3f}")
+print(f"Stability score: {result['statistics']['kappa']:.2f}")
+```
+
+### 3. Available Domains
+
+| Domain | Use Case | Method |
+|--------|----------|--------|
+| **Quantum** | Noise resilience in quantum circuits | `Universe.quantum()` |
+| **GPU** | Kernel optimization, cache tuning | `Universe.gpu()` |
+| **Financial** | Market regime detection, crash prediction | `Universe.finance()` |
+| **Climate** | Spatial scaling in weather data | `Universe.climate()` |
+| **Seismic** | Earthquake criticality analysis | `Universe.seismic()` |
+| **Magnetic** | Phase transitions (Ising model) | `Universe.magnetic()` |
+
+### 4. Run the Examples
+
+```bash
+# All examples are in examples_v4/
+python examples_v4/demo_quantum.py
+python examples_v4/demo_gpu.py
+python examples_v4/demo_finance.py
+python examples_v4/demo_climate.py
+python examples_v4/demo_seismic.py
+python examples_v4/demo_magnetic.py
+```
+
+Each demo generates a plot showing the critical point detection.
+
+### 5. Core Concept: Critical Susceptibility
+
+**What it does:** Finds the exact parameter value (σ_c) where a system transitions from stable to unstable.
+
+**Why it's better than traditional metrics:**
+- Detects **precursors** to failure, not just the failure itself
+- Works across completely different domains (quantum, finance, physics)
+- Statistically robust (bootstrap + permutation tests)
+
+**Key outputs:**
+- `sigma_c`: The critical scale/threshold
+- `kappa`: Stability score (higher = more critical)
+- `p_value`: Statistical significance
+
+### 6. Typical Workflow
+
+```python
+from sigma_c import Universe
+import numpy as np
+
+# 1. Initialize adapter
+adapter = Universe.gpu()
+
+# 2. Prepare your data
+# x = control parameter (e.g., noise level, cache size)
+# y = observable (e.g., performance, success rate)
+
+# 3. Compute susceptibility
+result = adapter.compute_susceptibility(x, y)
+
+# 4. Interpret results
+if result['kappa'] > 10:
+    print(f"⚠️ Critical behavior detected at σ_c = {result['sigma_c']}")
+else:
+    print("✓ System is stable")
+```
+
+### 7. Advanced: Custom Observables
+
+```python
+class MyAdapter(SigmaCAdapter):
+    def get_observable(self, data, **kwargs):
+        # Your custom metric here
+        return np.std(data) / np.mean(data)
+
+# Use it
+from sigma_c.adapters.factory import AdapterFactory
+AdapterFactory.register('custom', MyAdapter)
+my_adapter = AdapterFactory.create('custom')
+```
+
+### 8. C++ Integration (High Performance)
+
+```cpp
+#include <sigma_c/susceptibility.hpp>
+
+std::vector<double> x = {1.0, 2.0, 3.0, 4.0, 5.0};
+std::vector<double> y = {0.1, 0.3, 0.8, 1.5, 2.0};
+
+auto result = sigma_c::compute_susceptibility(x, y);
+std::cout << "Critical point: " << result.sigma_c << std::endl;
+```
+
+Link with: `-lsigma_c_core`
+
+### 9. Licensing
+
+**Dual License:**
+- **Open Source:** AGPL-3.0 (see `license_AGPL.txt`)
+- **Commercial:** Proprietary use without copyleft (contact: nfo@forgottenforge.xyz)
+
+### 10. Support & Documentation
+
+- **Full Docs:** See `DOCUMENTATION.md` (English + German)
+- **Examples:** `examples_v4/` directory
+- **Issues:** GitHub Issues
+- **Contact:** nfo@forgottenforge.xyz
+
+---
+
+## Common Use Cases
+
+### Quantum Computing
+```python
+qpu = Universe.quantum(device='simulator')
+result = qpu.run_optimization(
+    circuit_type='grover',
+    noise_levels=np.linspace(0, 0.1, 20)
+)
+# Finds the noise threshold where Grover's algorithm fails
+```
+
+### Financial Markets
+```python
+fin = Universe.finance()
+result = fin.detect_regime(symbol='SPY')
+# Detects if market is approaching a critical transition
+```
+
+### GPU Optimization
+```python
+gpu = Universe.gpu()
+result = gpu.auto_tune(alpha_levels=[0.1, 0.5, 0.9])
+# Finds optimal cache/memory configuration
+```
+
+---
+
+**Ready to use? Start with the examples and adapt them to your data!** 🚀

sigma_c_framework-1.0.0/README.md

@@ -0,0 +1,89 @@
+[![PyPI version](https://badge.fury.io/py/sigma-c-framework.svg)](https://badge.fury.io/py/sigma-c-framework)
+[![License: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+# Sigma-C Framework v1.0.0
+
+**Copyright (c) 2025 ForgottenForge.xyz**
+
+**Critical Susceptibility Framework** for Quantum, GPU, Financial, Climate, Seismic, and Magnetic analysis.
+
+## 🚀 Quick Start
+
+```bash
+# Install the package
+pip install sigma-c-framework
+
+# Run examples
+python -m sigma_c.examples.demo_quantum
+```
+
+Or clone and install from source:
+```bash
+git clone https://github.com/forgottenforge/sigmacore.git
+cd sigmacore/sigma_c_framework
+pip install .
+```
+
+## 🎯 What is Sigma-C?
+
+Sigma-C detects **critical phase transitions** in complex systems using Critical Susceptibility (χ) theory. Unlike traditional metrics, it identifies the precise scale where systems undergo fundamental structural changes.
+
+**Use Cases:**
+- 🔬 **Quantum Computing**: Find noise thresholds that break quantum algorithms
+- 🎮 **GPU Optimization**: Auto-tune kernels to avoid cache thrashing
+- 💰 **Finance**: Predict market crashes before they happen
+- 🌍 **Climate Science**: Identify characteristic scales of weather systems
+- 🌋 **Seismology**: Detect critical stress states in earthquake catalogs
+- 🧲 **Magnetism**: Analyze phase transitions (Curie temperature)
+
+## 📦 Features
+
+- **6 Domain Adapters** ready for production use
+- **High-Performance C++ Core** with Python bindings
+- **Statistical Robustness** via bootstrap and permutation tests
+- **Comprehensive Documentation** in English and German
+- **Dual License**: AGPL-3.0 or Commercial
+
+## 📚 Documentation
+
+- **Quick Start**: See [QUICKSTART.md](QUICKSTART.md) (5 minutes)
+- **Full Documentation**: See [DOCUMENTATION.md](DOCUMENTATION.md) (English + German)
+- **Release Guide**: See [RELEASE.md](RELEASE.md) (for contributors)
+- **Changelog**: See [CHANGELOG.md](CHANGELOG.md)
+
+## 💡 Example
+
+```python
+from sigma_c import Universe
+
+# Detect GPU performance critical point
+gpu = Universe.gpu()
+result = gpu.auto_tune(alpha_levels=[0.1, 0.5, 0.9])
+
+print(f"Critical threshold: {result['sigma_c']:.3f}")
+print(f"Stability score: {result['statistics']['kappa']:.2f}")
+```
+
+## 📄 License
+
+Dual-licensed under AGPL-3.0 or Commercial License.
+
+- **Open Source**: See [license_AGPL.txt](license_AGPL.txt)
+- **Commercial**: Contact nfo@forgottenforge.xyz
+
+For commercial licensing without AGPL-3.0 obligations, contact: **nfo@forgottenforge.xyz**
+
+## 🤝 Contributing
+
+Contributions are welcome! Please read our contributing guidelines and submit pull requests.
+
+## 📧 Contact
+
+- **Email**: nfo@forgottenforge.xyz
+- **GitHub**: [github.com/forgottenforge/sigmacore](https://github.com/forgottenforge/sigmacore)
+- **Issues**: [github.com/forgottenforge/sigmacore/issues](https://github.com/forgottenforge/sigmacore/issues)
+
+---
+
+**Made with ❤️ by ForgottenForge**

sigma_c_framework-1.0.0/examples_v4/debug_quantum.py

@@ -0,0 +1,11 @@
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from sigma_c.adapters.quantum import QuantumAdapter
+import inspect
+
+print(f"QuantumAdapter file: {inspect.getfile(QuantumAdapter)}")
+qpu = QuantumAdapter()
+print(f"Has run_optimization: {hasattr(qpu, 'run_optimization')}")
+print(f"Dir: {dir(qpu)}")

sigma_c_framework-1.0.0/examples_v4/demo_climate.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+Sigma-C Climate Demo
+==========================================================
+Copyright (c) 2025 ForgottenForge.xyz
+
+Demonstrates how to use the ClimateAdapter to analyze spatial scaling properties
+of temperature fields (ERA5 data).
+
+For commercial licensing without AGPL-3.0 obligations, contact:
+[nfo@forgottenforge.xyz]
+
+SPDX-License-Identifier: AGPL-3.0-or-later OR Commercial
+"""
+
+import sys
+import os
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Ensure we can import sigma_c from local source
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from sigma_c import Universe
+
+def main():
+    print("🌍 Starting Climate Spatial Analysis...")
+    
+    # 1. Initialize Climate Adapter
+    clim = Universe.climate()
+    print("✓ Climate Adapter initialized")
+    
+    # 2. Generate Mock Data (for demo purposes)
+    # In production, you would load real ERA5 parquet files.
+    print("✓ Generating synthetic temperature field...")
+    n_points = 5000
+    data = pd.DataFrame({
+        'lat': np.random.uniform(35, 70, n_points),
+        'lon': np.random.uniform(-10, 40, n_points),
+        # Create a synthetic field with a specific correlation length
+        'value': np.sin(np.random.uniform(35, 70, n_points)/5) * 10 + 15 + np.random.normal(0, 2, n_points)
+    })
+    
+    # 3. Run Spatial Scaling Analysis
+    print("✓ Computing gradient variance across scales...")
+    res = clim.analyze_spatial_scaling(data)
+    
+    sigma_c = res['sigma_c']
+    kappa = res['kappa']
+    
+    print("\n📊 Climate Status:")
+    print(f"   Critical Spatial Scale: {sigma_c:.1f} km")
+    print(f"   Organization Strength (κ): {kappa:.2f}")
+    
+    # 4. Visualize
+    try:
+        plt.figure(figsize=(10, 5))
+        
+        scales = res['sigma_range']
+        obs = res['observable']
+        
+        plt.plot(scales, obs, 'c-o', label='Gradient Variance')
+        plt.axvline(sigma_c, color='r', linestyle='--', label=f'Critical Scale {sigma_c:.0f}km')
+        
+        plt.xscale('log')
+        plt.xlabel("Spatial Scale (km)")
+        plt.ylabel("Gradient Variance")
+        plt.title("Climate Spatial Scaling Analysis")
+        plt.legend()
+        plt.grid(True, alpha=0.3)
+        
+        output_file = "climate_results.png"
+        plt.savefig(output_file)
+        print(f"✓ Plot saved to {output_file}")
+        
+    except Exception as e:
+        print(f"⚠️ Could not generate plot: {e}")
+
+if __name__ == "__main__":
+    main()