qang 0.4.0__tar.gz

qang-0.4.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vicente Humberto Monteverde
+
+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.

qang-0.4.0/PKG-INFO

@@ -0,0 +1,232 @@
+Metadata-Version: 2.4
+Name: qang
+Version: 0.4.0
+Summary: The Qang (qg): a unified angular-probability unit and metric for parametric quantum circuit design.
+Author-email: Vicente Humberto Monteverde <viny01958@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Viny2030/qang
+Project-URL: Repository, https://github.com/Viny2030/qang.git
+Project-URL: Bug Tracker, https://github.com/Viny2030/qang/issues
+Project-URL: Paper, https://doi.org/10.5281/zenodo.22832150
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Provides-Extra: qiskit
+Requires-Dist: qiskit>=1.0; extra == "qiskit"
+Requires-Dist: qiskit-aer; extra == "qiskit"
+Provides-Extra: cirq
+Requires-Dist: cirq>=1.0; extra == "cirq"
+Provides-Extra: pennylane
+Requires-Dist: pennylane>=0.42; python_version >= "3.10" and extra == "pennylane"
+Provides-Extra: hardware
+Requires-Dist: qiskit>=1.0; extra == "hardware"
+Requires-Dist: qiskit-aer; extra == "hardware"
+Requires-Dist: qiskit-ibm-runtime>=0.40; extra == "hardware"
+Provides-Extra: knitting
+Requires-Dist: qiskit>=1.0; extra == "knitting"
+Requires-Dist: qiskit-aer; extra == "knitting"
+Requires-Dist: qiskit-addon-cutting>=0.9; extra == "knitting"
+Provides-Extra: ionq
+Requires-Dist: qiskit>=1.0; extra == "ionq"
+Requires-Dist: qiskit-aer; extra == "ionq"
+Requires-Dist: qiskit-ionq>=1.0; python_version >= "3.10" and extra == "ionq"
+Requires-Dist: requests; extra == "ionq"
+Provides-Extra: qec
+Requires-Dist: pymatching>=2.0; extra == "qec"
+Provides-Extra: chemistry
+Requires-Dist: pyscf>=2.3; sys_platform != "win32" and extra == "chemistry"
+Requires-Dist: openfermion>=1.6; extra == "chemistry"
+Requires-Dist: openfermionpyscf>=0.5; sys_platform != "win32" and extra == "chemistry"
+Provides-Extra: examples
+Requires-Dist: scipy>=1.10; extra == "examples"
+Requires-Dist: matplotlib>=3.7; extra == "examples"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: matplotlib>=3.7; extra == "dev"
+Requires-Dist: scipy>=1.10; extra == "dev"
+Provides-Extra: all
+Requires-Dist: qiskit>=1.0; extra == "all"
+Requires-Dist: qiskit-aer; extra == "all"
+Requires-Dist: qiskit-ibm-runtime>=0.40; extra == "all"
+Requires-Dist: qiskit-addon-cutting>=0.9; extra == "all"
+Requires-Dist: qiskit-ionq>=1.0; python_version >= "3.10" and extra == "all"
+Requires-Dist: requests; extra == "all"
+Requires-Dist: pymatching>=2.0; extra == "all"
+Requires-Dist: cirq>=1.0; extra == "all"
+Requires-Dist: pennylane>=0.42; python_version >= "3.10" and extra == "all"
+Requires-Dist: scipy>=1.10; extra == "all"
+Requires-Dist: pytest>=7.0; extra == "all"
+Requires-Dist: matplotlib>=3.7; extra == "all"
+Dynamic: license-file
+
+# qang — The Qang (qg) Python Framework
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Viny2030/qang/blob/main/notebooks/qang_full_reference.ipynb)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.22832150.svg)](https://doi.org/10.5281/zenodo.22832150)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![Tests](https://github.com/Viny2030/qang/actions/workflows/tests.yml/badge.svg)](https://github.com/Viny2030/qang/actions/workflows/tests.yml)
+
+Reference implementation and computational toolkit for:
+
+> V. H. Monteverde, *"The Qang (qg): A Unified Angular-Probability Unit and Metric for Parametric Quantum Circuit Design."*
+> ORCID: [0000-0001-8884-4811](https://orcid.org/0000-0001-8884-4811) · DOI: [10.5281/zenodo.22832150](https://doi.org/10.5281/zenodo.22832150)
+
+`qang` bridges the gap between continuous Bloch-sphere rotation angles ($\theta \in [0, \pi]$) and projective measurement spaces in parameterized quantum circuits (PQAs). It provides native representations for:
+- **Polar Bias Qang ($qg_Z$):** $qg_Z(\theta) = \cos\theta = \langle\sigma_z\rangle \in [-1, 1]$.
+- **Measurement-Outcome Entropy Qang ($qg_S$):** $qg_S(\theta) = H(\cos^2(\theta/2)) \in [0, 1]$ (Shannon entropy of computational-basis outcomes).
+- Native SDK gate classes for **Qiskit**, **Cirq** and **PennyLane** (differentiable in qg_Z), regularized gradient optimizers, shot-noise error propagation, and density matrix/POVM metrics.
+
+---
+
+## Installation
+
+Install the minimal core library (NumPy only):
+```bash
+pip install "qang @ git+https://github.com/Viny2030/qang.git@v0.4.0"   # from GitHub
+pip install .             # or from a local clone
+```
+
+```bash
+pip install ".[qiskit]"   # Native Qiskit gate integration
+pip install ".[cirq]"     # Native Cirq gate integration
+pip install ".[pennylane]" # Native PennyLane operations (autodiff in qg_Z)
+pip install ".[hardware]" # IBM Quantum hardware / calibrated fake backends
+pip install ".[ionq]"     # IonQ simulator / hardware scripts (qiskit-ionq)
+pip install ".[qec]"      # Surface-code decoding examples (pymatching)
+pip install ".[chemistry]" # PySCF/OpenFermion molecules (Linux/macOS or WSL)
+pip install ".[all]"      # Everything except chemistry (Qiskit, IBM Runtime, IonQ, pymatching, Cirq, PennyLane, SciPy, Pytest, Matplotlib)
+pip install -r requirements.txt  # same as .[all], without installing qang itself
+```
+
+## Quickstart
+
+### 1. Basic Unit Conversions & Inversion
+```python
+from qang import Qang
+
+# Anchor values
+q_zero = Qang.from_angles(0.0, mode="polar")
+print(q_zero.value)  # +1.0 (|0>)
+
+q_max_ent = Qang.from_angles(1.5707963, mode="entropic")
+print(q_max_ent.value)  # 1.0 (Maximum measurement uncertainty)
+
+# Full Bloch sphere and statevector round-trip
+q = Qang.from_angles(theta=0.9, phi=1.1, mode="polar")
+bx, by, bz = q.to_bloch_vector()
+alpha, beta = q.to_statevector()
+
+# Engineering subunit (milliqang)
+print(Qang(0.5).milliqang)  # 500.0 m-qg
+```
+
+### 2. Qiskit Native Gate Integration
+```python
+from qang import Qang
+from qang.qiskit_gate import FullRQangGate
+from qiskit import QuantumCircuit
+
+qc = QuantumCircuit(1, 1)
+# Append gate directly parameterized in qg_Z without manual arccos conversion
+qc.append(FullRQangGate(Qang(0.5, phi=0.3)), [0])
+qc.measure(0, 0)
+```
+
+### 3. Cirq Native Gate Integration
+```python
+import cirq
+from qang import Qang
+from qang.cirq_gate import full_rqang_gate
+
+q = cirq.LineQubit(0)
+circuit = cirq.Circuit(
+    full_rqang_gate(Qang(0.5, phi=0.3)).on(q),
+    cirq.measure(q, key="m")
+)
+```
+
+### 3b. PennyLane: optimize directly in qg_Z
+```python
+import pennylane as qml
+from pennylane import numpy as pnp
+from qang.pennylane_gate import rqang
+
+dev = qml.device("default.qubit", wires=1)
+
+@qml.qnode(dev)
+def z_expval(qg):
+    rqang(qg, wires=0)          # RY(arccos(qg)), differentiable in qg
+    return qml.expval(qml.PauliZ(0))
+
+qg = pnp.array(0.3, requires_grad=True)
+print(qml.grad(z_expval)(qg))   # 1.0: <Z> = qg_Z exactly
+```
+
+### 4. Error Propagation & Shot Budgeting
+```python
+from qang.statistics import propagated_theta_std, confidence_interval_theta
+
+# First-order delta-method uncertainty: invariant across the Bloch sphere (~1/sqrt(N))
+std_theta = propagated_theta_std(theta=1.0, n_shots=10000)
+ci_lower, ci_upper = confidence_interval_theta(theta_hat=1.0, n_shots=10000, confidence=0.95)
+print(f"Theta 95% CI: [{ci_lower:.4f}, {ci_upper:.4f}] rad")
+```
+
+## Full Reference Notebook
+
+`notebooks/qang_full_reference.ipynb` is the single canonical, self-contained walkthrough
+of the whole project — the `Qang` class, the Section 4.1 gradient singularity (regularized
+and benchmarked), mixed states/POVMs, multi-qubit profiles, the native Qiskit and Cirq
+gates, shot-noise error propagation, Quantum Natural Gradient, a live round-trip against
+IonQ's cloud simulator, and a closing section that reformulates every result above into
+concrete, measured speed/cost comparisons (including one negative result, kept in on
+purpose). Open it directly in Colab with the badge above.
+
+Three further notebooks (in Spanish) cover the research notes:
+
+* `notebooks/qang_verificado.ipynb` — §1–§19: exact identities, blind spots, noise
+  diagnostics, optimization, knitting, few-shot estimation, QML, control quantization.
+* `notebooks/qang_avances_colab.ipynb` — §20–§39: the qg symmetry witness and filter
+  (chemistry, Hubbard, constrained QAOA), filter vs ZNE, qubit characterization, error
+  correction (Leung code, syndrome tracking), coherence, few-shot estimation, and the
+  recorded IonQ noisy-simulator runs, each with an honest "for / against" reading.
+  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Viny2030/qang/blob/main/notebooks/qang_avances_colab.ipynb)
+* `notebooks/qang_criptografia_colab.ipynb` — cryptography line, kept separate: why qg does
+  not apply to post-quantum cryptography, BB84 drift-vs-eavesdropper monitoring (§40) and
+  certified quantum random numbers (§41); companion PDF `manuscript/qang_criptografia.pdf`.
+  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Viny2030/qang/blob/main/notebooks/qang_criptografia_colab.ipynb)
+
+## Testing
+The package includes an extensive test suite (1108 tests, run in CI on Python 3.9–3.12) verifying analytical anchors, numerical stability, gradient regularizations, backend fidelity, and every numerical finding quoted in `RESEARCH_NOTES.md`:
+
+```bash
+pytest -v
+```
+
+## Contributing & Community
+We welcome contributions, bug reports, and suggestions!
+
+Issues: Please use the [GitHub Issue Tracker](https://github.com/Viny2030/qang/issues) to report bugs or request features.
+
+Contributions: See [CONTRIBUTING.md](CONTRIBUTING.md) for local development and pull request guidelines.
+
+## Citation
+If you use qang in your research, please cite the paper that defines the unit:
+
+```bibtex
+@article{monteverde2026qang,
+  title     = {The Qang (qg): A Unified Angular-Probability Unit and Metric for Parametric Quantum Circuit Design},
+  author    = {Monteverde, Vicente Humberto},
+  year      = {2026},
+  publisher = {Zenodo},
+  doi       = {10.5281/zenodo.22832150}
+}
+```
+
+and, for the software itself, the repository: <https://github.com/Viny2030/qang>.

qang-0.4.0/README.md

@@ -0,0 +1,166 @@
+# qang — The Qang (qg) Python Framework
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Viny2030/qang/blob/main/notebooks/qang_full_reference.ipynb)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.22832150.svg)](https://doi.org/10.5281/zenodo.22832150)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![Tests](https://github.com/Viny2030/qang/actions/workflows/tests.yml/badge.svg)](https://github.com/Viny2030/qang/actions/workflows/tests.yml)
+
+Reference implementation and computational toolkit for:
+
+> V. H. Monteverde, *"The Qang (qg): A Unified Angular-Probability Unit and Metric for Parametric Quantum Circuit Design."*
+> ORCID: [0000-0001-8884-4811](https://orcid.org/0000-0001-8884-4811) · DOI: [10.5281/zenodo.22832150](https://doi.org/10.5281/zenodo.22832150)
+
+`qang` bridges the gap between continuous Bloch-sphere rotation angles ($\theta \in [0, \pi]$) and projective measurement spaces in parameterized quantum circuits (PQAs). It provides native representations for:
+- **Polar Bias Qang ($qg_Z$):** $qg_Z(\theta) = \cos\theta = \langle\sigma_z\rangle \in [-1, 1]$.
+- **Measurement-Outcome Entropy Qang ($qg_S$):** $qg_S(\theta) = H(\cos^2(\theta/2)) \in [0, 1]$ (Shannon entropy of computational-basis outcomes).
+- Native SDK gate classes for **Qiskit**, **Cirq** and **PennyLane** (differentiable in qg_Z), regularized gradient optimizers, shot-noise error propagation, and density matrix/POVM metrics.
+
+---
+
+## Installation
+
+Install the minimal core library (NumPy only):
+```bash
+pip install "qang @ git+https://github.com/Viny2030/qang.git@v0.4.0"   # from GitHub
+pip install .             # or from a local clone
+```
+
+```bash
+pip install ".[qiskit]"   # Native Qiskit gate integration
+pip install ".[cirq]"     # Native Cirq gate integration
+pip install ".[pennylane]" # Native PennyLane operations (autodiff in qg_Z)
+pip install ".[hardware]" # IBM Quantum hardware / calibrated fake backends
+pip install ".[ionq]"     # IonQ simulator / hardware scripts (qiskit-ionq)
+pip install ".[qec]"      # Surface-code decoding examples (pymatching)
+pip install ".[chemistry]" # PySCF/OpenFermion molecules (Linux/macOS or WSL)
+pip install ".[all]"      # Everything except chemistry (Qiskit, IBM Runtime, IonQ, pymatching, Cirq, PennyLane, SciPy, Pytest, Matplotlib)
+pip install -r requirements.txt  # same as .[all], without installing qang itself
+```
+
+## Quickstart
+
+### 1. Basic Unit Conversions & Inversion
+```python
+from qang import Qang
+
+# Anchor values
+q_zero = Qang.from_angles(0.0, mode="polar")
+print(q_zero.value)  # +1.0 (|0>)
+
+q_max_ent = Qang.from_angles(1.5707963, mode="entropic")
+print(q_max_ent.value)  # 1.0 (Maximum measurement uncertainty)
+
+# Full Bloch sphere and statevector round-trip
+q = Qang.from_angles(theta=0.9, phi=1.1, mode="polar")
+bx, by, bz = q.to_bloch_vector()
+alpha, beta = q.to_statevector()
+
+# Engineering subunit (milliqang)
+print(Qang(0.5).milliqang)  # 500.0 m-qg
+```
+
+### 2. Qiskit Native Gate Integration
+```python
+from qang import Qang
+from qang.qiskit_gate import FullRQangGate
+from qiskit import QuantumCircuit
+
+qc = QuantumCircuit(1, 1)
+# Append gate directly parameterized in qg_Z without manual arccos conversion
+qc.append(FullRQangGate(Qang(0.5, phi=0.3)), [0])
+qc.measure(0, 0)
+```
+
+### 3. Cirq Native Gate Integration
+```python
+import cirq
+from qang import Qang
+from qang.cirq_gate import full_rqang_gate
+
+q = cirq.LineQubit(0)
+circuit = cirq.Circuit(
+    full_rqang_gate(Qang(0.5, phi=0.3)).on(q),
+    cirq.measure(q, key="m")
+)
+```
+
+### 3b. PennyLane: optimize directly in qg_Z
+```python
+import pennylane as qml
+from pennylane import numpy as pnp
+from qang.pennylane_gate import rqang
+
+dev = qml.device("default.qubit", wires=1)
+
+@qml.qnode(dev)
+def z_expval(qg):
+    rqang(qg, wires=0)          # RY(arccos(qg)), differentiable in qg
+    return qml.expval(qml.PauliZ(0))
+
+qg = pnp.array(0.3, requires_grad=True)
+print(qml.grad(z_expval)(qg))   # 1.0: <Z> = qg_Z exactly
+```
+
+### 4. Error Propagation & Shot Budgeting
+```python
+from qang.statistics import propagated_theta_std, confidence_interval_theta
+
+# First-order delta-method uncertainty: invariant across the Bloch sphere (~1/sqrt(N))
+std_theta = propagated_theta_std(theta=1.0, n_shots=10000)
+ci_lower, ci_upper = confidence_interval_theta(theta_hat=1.0, n_shots=10000, confidence=0.95)
+print(f"Theta 95% CI: [{ci_lower:.4f}, {ci_upper:.4f}] rad")
+```
+
+## Full Reference Notebook
+
+`notebooks/qang_full_reference.ipynb` is the single canonical, self-contained walkthrough
+of the whole project — the `Qang` class, the Section 4.1 gradient singularity (regularized
+and benchmarked), mixed states/POVMs, multi-qubit profiles, the native Qiskit and Cirq
+gates, shot-noise error propagation, Quantum Natural Gradient, a live round-trip against
+IonQ's cloud simulator, and a closing section that reformulates every result above into
+concrete, measured speed/cost comparisons (including one negative result, kept in on
+purpose). Open it directly in Colab with the badge above.
+
+Three further notebooks (in Spanish) cover the research notes:
+
+* `notebooks/qang_verificado.ipynb` — §1–§19: exact identities, blind spots, noise
+  diagnostics, optimization, knitting, few-shot estimation, QML, control quantization.
+* `notebooks/qang_avances_colab.ipynb` — §20–§39: the qg symmetry witness and filter
+  (chemistry, Hubbard, constrained QAOA), filter vs ZNE, qubit characterization, error
+  correction (Leung code, syndrome tracking), coherence, few-shot estimation, and the
+  recorded IonQ noisy-simulator runs, each with an honest "for / against" reading.
+  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Viny2030/qang/blob/main/notebooks/qang_avances_colab.ipynb)
+* `notebooks/qang_criptografia_colab.ipynb` — cryptography line, kept separate: why qg does
+  not apply to post-quantum cryptography, BB84 drift-vs-eavesdropper monitoring (§40) and
+  certified quantum random numbers (§41); companion PDF `manuscript/qang_criptografia.pdf`.
+  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Viny2030/qang/blob/main/notebooks/qang_criptografia_colab.ipynb)
+
+## Testing
+The package includes an extensive test suite (1108 tests, run in CI on Python 3.9–3.12) verifying analytical anchors, numerical stability, gradient regularizations, backend fidelity, and every numerical finding quoted in `RESEARCH_NOTES.md`:
+
+```bash
+pytest -v
+```
+
+## Contributing & Community
+We welcome contributions, bug reports, and suggestions!
+
+Issues: Please use the [GitHub Issue Tracker](https://github.com/Viny2030/qang/issues) to report bugs or request features.
+
+Contributions: See [CONTRIBUTING.md](CONTRIBUTING.md) for local development and pull request guidelines.
+
+## Citation
+If you use qang in your research, please cite the paper that defines the unit:
+
+```bibtex
+@article{monteverde2026qang,
+  title     = {The Qang (qg): A Unified Angular-Probability Unit and Metric for Parametric Quantum Circuit Design},
+  author    = {Monteverde, Vicente Humberto},
+  year      = {2026},
+  publisher = {Zenodo},
+  doi       = {10.5281/zenodo.22832150}
+}
+```
+
+and, for the software itself, the repository: <https://github.com/Viny2030/qang>.

qang-0.4.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=77.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qang"
+version = "0.4.0"
+description = "The Qang (qg): a unified angular-probability unit and metric for parametric quantum circuit design."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT" 
+authors = [
+    { name = "Vicente Humberto Monteverde", email = "viny01958@gmail.com" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Physics",
+    "Intended Audience :: Science/Research",
+]
+dependencies = [
+    "numpy>=1.24",
+]
+
+[project.optional-dependencies]
+qiskit = ["qiskit>=1.0", "qiskit-aer"]
+cirq = ["cirq>=1.0"]
+pennylane = ['pennylane>=0.42; python_version >= "3.10"']
+hardware = ["qiskit>=1.0", "qiskit-aer", "qiskit-ibm-runtime>=0.40"]
+knitting = ["qiskit>=1.0", "qiskit-aer", "qiskit-addon-cutting>=0.9"]
+ionq = ["qiskit>=1.0", "qiskit-aer", 'qiskit-ionq>=1.0; python_version >= "3.10"', "requests"]
+qec = ["pymatching>=2.0"]
+chemistry = ['pyscf>=2.3; sys_platform != "win32"', "openfermion>=1.6", 'openfermionpyscf>=0.5; sys_platform != "win32"']
+examples = ["scipy>=1.10", "matplotlib>=3.7"]
+dev = ["pytest>=7.0", "matplotlib>=3.7", "scipy>=1.10"]
+all = ["qiskit>=1.0", "qiskit-aer", "qiskit-ibm-runtime>=0.40", "qiskit-addon-cutting>=0.9", 'qiskit-ionq>=1.0; python_version >= "3.10"', "requests", "pymatching>=2.0", "cirq>=1.0", 'pennylane>=0.42; python_version >= "3.10"', "scipy>=1.10", "pytest>=7.0", "matplotlib>=3.7"]
+
+[project.urls]
+Homepage = "https://github.com/Viny2030/qang"
+Repository = "https://github.com/Viny2030/qang.git"
+"Bug Tracker" = "https://github.com/Viny2030/qang/issues"
+Paper = "https://doi.org/10.5281/zenodo.22832150"
+
+[tool.setuptools.packages.find]
+include = ["qang*"]

qang-0.4.0/qang/__init__.py

@@ -0,0 +1,43 @@
+"""
+qang — A Unified Angular-Probability Unit for Parametric Quantum Circuit Design.
+
+Reference implementation for:
+    V. H. Monteverde, "The Qang (qg): A Unified Angular-Probability Unit and
+    Metric for Parametric Quantum Circuit Design." ORCID: 0000-0001-8884-4811
+    https://doi.org/10.5281/zenodo.22832150
+
+This package covers, in order:
+  - qang.core        the qg_Z / qg_S unit exactly as defined in the paper
+                      (Section 2), plus the full Bloch-sphere (theta, phi)
+                      representation consolidated from the author's
+                      exploratory notebook.
+  - qang.gradients    the coordinate-singularity limitation from Section 4.1,
+                       a regularized alternative, and a toy VQE benchmark
+                       comparing theta-space vs qg-space optimization
+                       (Future Research Direction #3).
+  - qang.mixed        generalization to mixed states and POVMs
+                       (Future Research Direction #4, part 1).
+  - qang.multiqubit   generalization to multi-qubit tensor-product
+                       projection profiles (Future Research Direction #4,
+                       part 2).
+  - qang.qiskit_gate  qg as a native single-qubit gate for Qiskit
+                       (Future Research Direction #1). Optional: only
+                       importable if qiskit is installed.
+  - qang.cirq_gate    the same for Cirq (optional: needs cirq).
+  - qang.statistics   shot-noise error propagation theta <-> qg, and
+                       few-shot qg_Z intervals (Haar-prior Bayes, Wilson).
+  - qang.phase        the qg_Phi phase unit.
+  - qang.transformations  closed-form transition probabilities.
+  - qang.knitting     the sampling cost of circuit cutting in qg units.
+  - qang.circuits, qang.ansatze, qang.qec, qang.algorithms
+                       Qiskit circuit builders, variational ansatze, the
+                       3-qubit bit-flip code, and textbook algorithms
+                       (optional: need qiskit).
+
+See RESEARCH_NOTES.md for the derivations and results behind each module.
+"""
+
+from .core import Qang, MILLIQANG_PER_QANG
+
+__all__ = ["Qang", "MILLIQANG_PER_QANG"]
+__version__ = "0.4.0"