dense-evolution 8.0.2__tar.gz → 8.0.3__tar.gz

dense_evolution-8.0.3/LICENSE.md

@@ -0,0 +1,61 @@
+# Business Source License 1.1 (BSL 1.1)
+
+**Software:** Dense Evolution  
+**Licensor:** Salvatore Pennacchio <jtatopenn@libero.it> [tatopenn-cell]  
+
+This Business Source License (the "License") applies to the source code, object code, algorithms, and configuration files of the software named "Dense Evolution" (the "Software").
+
+## 1. License Parameters
+
+* **Licensor:** Salvatore Pennacchio <jtatopenn@libero.it> [tatopenn-cell]
+* **Software:** Dense Evolution (including updates, patches, kernel optimizations, and derivative works provided by the Licensor)
+* **Change Date:** June 1, 2029
+* **Change License:** Apache License, Version 2.0 (or subsequent versions, at the Licensor's sole discretion)
+* **Licensed Use for Production:** Strictly non-commercial use. For use in commercial or industrial production environments, the computational limits set forth in Section 4 (Additional Use Grant) shall strictly apply.
+
+---
+
+## 2. Grant of License and Attribution Obligation
+
+Subject to the terms and computational limitations established herein, the Licensor hereby grants to the Licensee a non-exclusive, worldwide, royalty-free, and irrevocable (conditional upon continuous compliance with these terms) license to use, reproduce, distribute, modify, and create derivative works of the Software.
+
+**Mandatory Attribution Condition:** Any copy, portion, or derivative work of the Software (including third-party software, cloud platforms, or API interfaces integrating Dense Evolution) must visibly, permanently, and unaltered include the original copyright notice and attribution to the Licensor in the following format:  
+`© 2026 Salvatore Pennacchio <jtatopenn@libero.it> [tatopenn-cell] - Dense Evolution`.
+
+---
+
+## 3. General Use Conditions and Restrictions
+
+The Software may be used, reproduced, distributed, and modified, provided that such use is **not intended for commercial production purposes** or for providing commercial cloud/computational services that compete directly with the products or services offered by the Licensor, except as expressly permitted under Section 4 or as of the Change Date (Section 5).
+
+---
+
+## 4. Additional Use Grant (Limited Commercial Use)
+
+Notwithstanding the restrictions in Section 3, the Licensee is authorized to use the Software for commercial production, industrial, or paid consulting purposes, without the need for a separate paid license, exclusively if the following computational limits are respected:
+
+* **Total Qubit Limit:** The executed quantum simulation must not exceed a size of **24 qubits allocated in memory**. This limit applies to the cumulative sum of all instances, processes, threads, or parallel cluster nodes running concurrently by the same organization or end user.
+* **Circuits and Shots Limit:** The maximum computational volume allowed in a production environment is fixed at **1000 distinct quantum circuit structures per day**, each of which may be executed for a maximum of **10,000 equivalent samples (shots)** per individual circuit.
+
+Any use that exceeds or circumvents (via splitting, wrapping, or proxy techniques) any single parameter listed above strictly requires the prior execution of a separate commercial license agreement with the Licensor.
+
+---
+
+## 5. Transition to Change License
+
+As of **June 1, 2029** (the "Change Date"), this License shall automatically cease to have effect on the Software and all versions released prior to that date. From that moment forward, the Software will permanently and freely become available under the terms of the **Apache License 2.0**. Until the Change Date, this BSL 1.1 License shall remain in full force, validity, and effect.
+
+---
+
+## 6. Disclaimer of Warranty and Limitation of Liability
+
+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.
+
+---
+
+## 7. Governing Law and Jurisdiction
+
+This License shall be governed by, construed, and enforced in accordance with the laws of **Italy**. Any dispute arising out of or in connection with the interpretation, execution, or validity of this License shall be submitted to the exclusive jurisdiction of the **Court of Milan, Italy**.
+

{dense_evolution-8.0.2 → dense_evolution-8.0.3}/PKG-INFO

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: dense-evolution
-Version: 8.0.2
+Version: 8.0.3
 Summary: Micro-optimized High-Performance NISQ Statevector Quantum Circuit Simulator (Hardware-Adaptive Integration of Native NumPy, CUDA-Accelerated CuPy, and Linear Kernel Fusion via JAX JIT/XLA Compilation)
 Author-email: Salvatore Pennacchio <jtatopenn@libero.it>
-License: MIT
+License: Business Source License 1.1
 Project-URL: Homepage, https://github.com/tatopenn-cell/Dense-Evolution
-Project-URL: Documentation, https://github.com/tatopenn-cell/Dense-Evolution/wiki
+Project-URL: Documentation, https://github.com/tatopenn-cell/Dense-Evolution/blob/main/LICENSE
 Project-URL: Repository, https://github.com/tatopenn-cell/Dense-Evolution
 Project-URL: Bug Tracker, https://github.com/tatopenn-cell/Dense-Evolution/blob/main/dense_evolution.py
 Keywords: quantum-computing,quantum-simulation,statevector,jax,cupy,cuda-acceleration,openqasm,nisq-noise,hpc,linear-kernel-fusion
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -22,6 +22,7 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE.md
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: matplotlib>=3.5.0
 Requires-Dist: psutil>=5.9.0
@@ -34,6 +35,7 @@ Provides-Extra: full
 Requires-Dist: jax>=0.4.0; extra == "full"
 Requires-Dist: jaxlib>=0.4.0; extra == "full"
 Requires-Dist: cupy-cuda12x>=12.0.0; extra == "full"
+Dynamic: license-file
 
 # 💎 Dense Evolution
 
@@ -41,7 +43,7 @@ Requires-Dist: cupy-cuda12x>=12.0.0; extra == "full"
 [![CI](https://github.com/tatopenn-cell/Dense-Evolution/actions/workflows/ci.yml/badge.svg)](https://github.com/tatopenn-cell/Dense-Evolution/actions/workflows/ci.yml)
 [![PyPI version](https://img.shields.io/pypi/v/dense-evolution?style=flat-square)](https://pypi.org/project/dense-evolution/)
 [![Python Version](https://img.shields.io/badge/Python-3.9+-blue?style=flat-square&logo=python)](https://www.python.org/)
-[![License](https://img.shields.io/badge/License-MIT-yellow?style=flat-square)](https://github.com/tatopenn-cell/Dense-Evolution/blob/main/LICENSE)
+[![License](https://img.shields.io/badge/License-BSL_1.1-orange?style=flat-square)](https://github.com/tatopenn-cell/Dense-Evolution/blob/main/LICENSE)
 [![Build](https://img.shields.io/badge/Build-Passing-success?style=flat-square)](https://github.com/tatopenn-cell/Dense-Evolution/actions)
 
 # pip install dense-evolution
@@ -330,32 +332,76 @@ Dense-Evolution/
 
 ---
 
-## 📜 Licenza e Note Legali
+## 📜 License and Legal Notice
+
+This project is distributed under the terms of the **Business Source License 1.1 (BSL 1.1)**. 
+
+* **Non-Commercial Use:** Completely free and open for research, academic, and non-commercial purposes.
+* **Limited Commercial Use:** Free for commercial production up to **24 qubits** and **1,000 circuits (with max 10,000 shots each) per day**. Any use beyond these limits requires a separate commercial license.
+* **Future Open Source Transition:** On **June 1, 2026**, this project will automatically transition to a fully open-source **Apache License 2.0**.
 
-Il progetto è interamente distribuito sotto i termini della licenza **MIT**.
 
 ```text
-MIT License
-
-Copyright (c) 2026 salvatore pennacchio [tatopenn-cell]
-
-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.
+# Business Source License 1.1 (BSL 1.1)
+
+**Software:** Dense Evolution  
+**Licensor:** Salvatore Pennacchio <jtatopenn@libero.it> [tatopenn-cell]  
+
+This Business Source License (the "License") applies to the source code, object code, algorithms, and configuration files of the software named "Dense Evolution" (the "Software").
+
+## 1. License Parameters
+
+* **Licensor:** Salvatore Pennacchio <jtatopenn@libero.it> [tatopenn-cell]
+* **Software:** Dense Evolution (including updates, patches, kernel optimizations, and derivative works provided by the Licensor)
+* **Change Date:** June 1, 2029
+* **Change License:** Apache License, Version 2.0 (or subsequent versions, at the Licensor's sole discretion)
+* **Licensed Use for Production:** Strictly non-commercial use. For use in commercial or industrial production environments, the computational limits set forth in Section 4 (Additional Use Grant) shall strictly apply.
+
+---
+
+## 2. Grant of License and Attribution Obligation
+
+Subject to the terms and computational limitations established herein, the Licensor hereby grants to the Licensee a non-exclusive, worldwide, royalty-free, and irrevocable (conditional upon continuous compliance with these terms) license to use, reproduce, distribute, modify, and create derivative works of the Software.
+
+**Mandatory Attribution Condition:** Any copy, portion, or derivative work of the Software (including third-party software, cloud platforms, or API interfaces integrating Dense Evolution) must visibly, permanently, and unaltered include the original copyright notice and attribution to the Licensor in the following format:  
+`© 2026 Salvatore Pennacchio <jtatopenn@libero.it> [tatopenn-cell] - Dense Evolution`.
+
+---
+
+## 3. General Use Conditions and Restrictions
+
+The Software may be used, reproduced, distributed, and modified, provided that such use is **not intended for commercial production purposes** or for providing commercial cloud/computational services that compete directly with the products or services offered by the Licensor, except as expressly permitted under Section 4 or as of the Change Date (Section 5).
+
+---
+
+## 4. Additional Use Grant (Limited Commercial Use)
+
+Notwithstanding the restrictions in Section 3, the Licensee is authorized to use the Software for commercial production, industrial, or paid consulting purposes, without the need for a separate paid license, exclusively if the following computational limits are respected:
+
+* **Total Qubit Limit:** The executed quantum simulation must not exceed a size of **24 qubits allocated in memory**. This limit applies to the cumulative sum of all instances, processes, threads, or parallel cluster nodes running concurrently by the same organization or end user.
+* **Circuits and Shots Limit:** The maximum computational volume allowed in a production environment is fixed at **1000 distinct quantum circuit structures per day**, each of which may be executed for a maximum of **10,000 equivalent samples (shots)** per individual circuit.
+
+Any use that exceeds or circumvents (via splitting, wrapping, or proxy techniques) any single parameter listed above strictly requires the prior execution of a separate commercial license agreement with the Licensor.
+
+---
+
+## 5. Transition to Change License
+
+As of **June 1, 2029** (the "Change Date"), this License shall automatically cease to have effect on the Software and all versions released prior to that date. From that moment forward, the Software will permanently and freely become available under the terms of the **Apache License 2.0**. Until the Change Date, this BSL 1.1 License shall remain in full force, validity, and effect.
+
+---
+
+## 6. Disclaimer of Warranty and Limitation of Liability
+
+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.
+
+---
+
+## 7. Governing Law and Jurisdiction
+
+This License shall be governed by, construed, and enforced in accordance with the laws of **Italy**. Any dispute arising out of or in connection with the interpretation, execution, or validity of this License shall be submitted to the exclusive jurisdiction of the **Court of Milan, Italy**.
 ```
 
 ## 💎 Technical Appendix: Advanced JAX XLA Optimizations
@@ -399,75 +445,47 @@ jax.block_until_ready(sv_final)
 
 print(f"🚀 Tempo di calcolo puro in Beast Mode: {time.time() - start:.6f} secondi")
 ```
-## 🛠️ 2. Native OpenQASM 2.0 Integration via QASMParser
-The QASMParser module parses OpenQASM 2.0 source code, translating instructions directly into the flat linear format required by the simulation backend. The raw text string is processed natively by the parse() method, which outputs a valid QASMCircuit object. This architecture eliminates the need for external dictionary maps or manual type adapters.
-Before execution, the circuit object can be verified through the native validate() method to guarantee structural integrity and prevent runtime exceptions during deep JIT compilation.
-
-## OpenQASM 2.0 Parsing and Execution Example:
-
-```python
-import dense_evolution as de
-
-# Stringa QASM 2.0 standard
-qasm_string = """
-OPENQASM 2.0;
-include "qelib1.inc";
-qreg q[2];
-h q[0];
-cx q[0], q[1];"""
-
-# 1. Inizializzazione del simulatore e del parser
-sim = de.DenseSVSimulator(n_qubits=2)
-parser = de.QASMParser()
 
-# 2. Parsing direct
-parsed_circuit = parser.parse(qasm_string)
+## 🪐 High-Performance OpenQASM 3.0 Hybrid Execution Engine
 
-# DEBUG: Print the structure of parsed_circuit.ops
-print(f"DEBUG: parsed_circuit.ops type: {type(parsed_circuit.ops)}")
-print(f"DEBUG: parsed_circuit.ops content: {parsed_circuit.ops}")
+The `DenseSVSimulator` features an integrated OpenQASM 3.0 compilation pipeline. It bridges hardware specifications with optimized static compilation layers. The engine maps high-level instructions directly into unified JAX XLA operations, eliminating tracking degradation and runtime interpreter bottlenecks.
 
-# 3. Esecution of circuit in Beast Mode
-# According to dense_evolution.py source code, the QASMCircuit object stores gates in 'ops' attribute.
-# The previous KeyError indicates a format mismatch, not an AttributeError.
-# We need to convert parsed_circuit.ops to the format expected by run_circuit_jit_beast_mode.
+### ⚙️ Key Computational Paradigms
 
-converted_circuit_list = []
-for op in parsed_circuit.ops:
-    # Correctly access 'qubits' key instead of 'qargs'
-    gate_name = op['name']
-    qubits = op['qubits']
-    # Combine name and qubits into a tuple, ensuring qubits are appended as individual arguments
-    converted_circuit_list.append(tuple([gate_name] + qubits))
+* **Zero-Overhead Control Flow**
+  Conditional `if/else` branches compile without breaking execution streams.
+  This setup eliminates host-level loop delays during mid-circuit measurements.
 
-sim.run_circuit_jit_beast_mode(converted_circuit_list)
+* **Micro-Fused AST Translation**
+  The `QASMParser` resolves complex sub-routines and multi-dimensional registers.
+  It generates a flattened primitive topology for the Beast Mode engine.
 
-statevector = sim.get_statevector()
-print(f"✅ State final after parsing QASM: {statevector}")
-print(f"Probability  extraction: {sim.get_probabilities()}")
-```
+* **Deterministic Resource Bound**
+  Strictly handles dynamic mathematical arguments like $\text{rx}(\pi/4 \times \theta)$.
+  It preserves a machine-epsilon zero-drift footprint ($\Delta = 1.11 \times 10^{-16}$) during updates.
 
-## Simulating and Measuring the QASM 3.0 Circuit
-Now, let's simulate the QASM 3.0 circuit we just parsed and see the measurement results using the DenseSVSimulator's measure method.
 
 ```python
 import dense_evolution as de
+import numpy as np
 
-# Re-instantiate the parser and parse the QASM 3.0 string (if not already in scope)
-parser = de.QASMParser()
-qasm3_circuit_str = """
-OPENQASM 3.0;
-qubit[4] q;
+sim = de.DenseSVSimulator(n_qubits=3, use_gpu=False, use_float32=False)
+
+qasm3_program = """OPENQASM 3.0;
+include "stdgates.inc";
+qubit[3] q;
 bit[2] c;
 h q[0];
 cx q[0], q[1];
-rz(pi/2) q[2];
-measure q[0] -> c[0];
-measure q[1] -> c[1];
+bit c[0] = measure q[0];
+if (c[0] == 1) {
+    x q[2];
+}
 """
-parsed_circuit = parser.parse(qasm3_circuit_str)
 
-# Helper function to convert parsed dictionary operations to simulator-compatible tuples
+parser = de.QASMParser()
+parsed_circuit = parser.parse(qasm3_program)
+
 def convert_ops_for_simulator(ops_list):
     converted_ops = []
     for op in ops_list:
@@ -475,50 +493,26 @@ def convert_ops_for_simulator(ops_list):
         qubits = op['qubits']
         params = op['params']
         if params:
-            # For parametric gates, format is (name, param1, ..., paramN, qubit1, ..., qubitN)
             converted_ops.append(tuple([name] + params + qubits))
         else:
-            # For non-parametric gates, format is (name, qubit1, ..., qubitN)
             converted_ops.append(tuple([name] + qubits))
     return converted_ops
 
-# Convert the parsed circuit operations
-simulator_ops = convert_ops_for_simulator(parsed_circuit.ops)
+circuit_operations = convert_ops_for_simulator(parsed_circuit.ops)
+sim.run_circuit_jit_beast_mode(circuit_operations)
 
-# Instantiate the DenseSVSimulator
-sim = de.DenseSVSimulator(n_qubits=parsed_circuit.n_qubits)
+final_state = sim.get_statevector()
 
-# Run the parsed circuit through the simulator
-# We'll run it a few times to see different measurement outcomes due to quantum randomness
-print("\n--- Simulating and Measuring ---")
-num_shots = 10
-measurements = []
-for _ in range(num_shots):
-    sim.set_initial_state() # Corrected: used set_initial_state() instead of reset_state()
-    sim.run_circuit_jit_beast_mode(simulator_ops) # Use the converted operations list
+print("\n" + "="*60)
+print("📊 REPORT - DENSE-EVOLUTION OPENQASM 3.0")
+print("="*60)
+print(f"🔹 Probability Vector:\n{sim.get_probabilities()}\n")
 
-    # Measure individual qubits as specified in the QASM circuit
-    # sim.measure(qubit_idx) returns 0 or 1 for the specified qubit
-    measured_c0 = sim.measure(0) # Measure q[0] into c[0]
-    measured_c1 = sim.measure(1) # Measure q[1] into c[1]
-    measurements.append((measured_c0, measured_c1))
+norma = np.sum(np.abs(final_state)**2)
+print(f"🔹 State Unitary Tolerance: {norma:.4f}")
+print("🔍 Drift Verification:", "DONE" if np.isclose(norma, 1.0) else "ANOMALY")
+print("="*60)
 
-print(f"Measurements (c0, c1) over {num_shots} shots: {measurements}")
-
-# To get probabilities of all states (without classical bit mapping from QASM measure),
-# you can use `get_probabilities()` directly after running the circuit.
-print("\n--- Probabilities of all states (after 1 run) ---")
-sim.set_initial_state()
-sim.run_circuit_jit_beast_mode(simulator_ops)
-probabilities = sim.get_probabilities()
-print(probabilities)
-
-# Display top probabilities for clarity
-import numpy as np
-sorted_indices = np.argsort(probabilities)[::-1]
-print("\nTop 5 probabilities:")
-for i in sorted_indices[:5]:
-    print(f"State |{i:0{parsed_circuit.n_qubits}b}⟩: {probabilities[i]:.4f}")
 ```
 ------------------------------
 ## 🧠 3. Stochastic Noise Simulation (NoiseModel)
@@ -1144,34 +1138,36 @@ print("="*80)
 * Circuit optimization loops: VQE, QAOA, variational algorithms with fixed structure
 * Shot-based sampling simulation: Execute same circuit many times with different measurements
 
-## ⚠️ Current Limitations
+## ⚠️ Performance & Scaling Limitations
+
+* **Memory Overhead:** The dense statevector simulation approach scales exponentially. On standard hardware architectures, execution is optimal up to **~24 qubits**. For deep or larger scale systems, consider alternative approaches like Matrix Product States (MPS).
+* **Licensing Threshold:** Please note that while the hardware can push further, commercial production use is capped at **24 qubits** under the terms of the BSL 1.1 license.
+
+## 🚀 Hardware Recommendations & Benchmarks
 
-* Memory: Dense statevector limited to ~24 qubits on standard hardware (use MPS for larger systems)
 
-## Hardware Recommendations
+| Hardware Platform | Max Practical Qubits (Dense) | Performance Gain vs Qiskit | Operational Notes |
+| :--- | :---: | :---: | :--- |
+| **Standard CPU** *(e.g., Colab Free)* | 24 | **120x – 5,000x+** | Verified and benchmarked baseline configuration. |
+| **High-RAM CPU** *(16+ GB RAM)* | 26 | **120x – 5,000x+** | Performance scales with host memory bandwidth. |
+| **NVIDIA GPU** *(CUDA-Enabled)* | 28+ | **10,000x+** * | Accelerated via CuPy backend execution. |
+| **Google Cloud TPU** | 28+ | **20,000x+** * | Optimized via JAX native XLA compilation. |
 
-| Hardware | Max Qubits (Dense) | Speedup vs Qiskit | Notes |
-|---|---|---|---|
-| CPU (Colab Free) | 24 | 120-5000x+ | Tested configuration |
-| CPU (High RAM) | 26 | 120-5000x+ | 16+ GB recommended |
-| NVIDIA GPU | 28+ | 10000x+* | CUDA-enabled, estimated |
-| TPU | 28+ | 20000x+* | Google Cloud, estimated |
+*\*Note: GPU/TPU performance gains are projected based on JAX/XLA scaling characteristics and native kernel execution profiles. Full automated benchmarks will be introduced in upcoming releases.*
 
-*GPU/TPU speedups are projected based on JAX scaling characteristics and will be benchmarked in future releases.
+## 🧠 Architectural Insights: Why is it so fast?
 
-## Why These Results?
+1. **JAX JIT Compilation:** Circuit operations are JIT-compiled directly into highly optimized XLA machine code, entirely bypassing the Python interpreter overhead.
+2. **Linear Kernel Fusion:** Multiple sequential gate operations are fused dynamically into single monolithic CPU/GPU computational kernels, minimizing memory roundtrips.
+3. **Hardware-Adaptive Memory Layout:** Contiguous statevector memory storage architecture, highly optimized for vectorization and parallel cache locality.
+4. **Graph Caching:** Compiled execution graphs are automatically cached and reused across subsequent execution loops or optimization shots.
 
-   1. JAX JIT Compilation: Circuit operations compiled to optimized XLA code, eliminating Python interpreter overhead
-   2. Kernel Fusion: Multiple gate operations fused into single GPU/CPU kernels
-   3. Memory Layout: Contiguous statevector storage optimized for vectorized operations
-   4. Caching: Compiled functions cached and reused across executions
+## 🤝 Contribute Benchmarks
 
-## Contribute Benchmarks
-Found better (or worse) results on your hardware? Open an issue or PR with:
+Discovered different scaling behavior or performance metrics on your specific hardware stack? Help us refine and map the performance of **Dense Evolution**! Please open an Issue or Pull Request providing:
 
-* Hardware specs (CPU/GPU, RAM)
-* Benchmark code
-* Timing results
+* **Hardware Topology:** Exact CPU/GPU models, Host RAM, and CUDA toolkit version.
+* **Reproducible Example:** Code snippet or script used for the test run.
+* **Execution Metrics:** Timing results and memory allocation logs.
 
-Help us optimize Dense-Evolution for your use case!