aleshaq-sdk 0.1.0__tar.gz

aleshaq_sdk-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,38 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  pypi-publish:
+    name: Upload release to PyPI
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/aleshaq-sdk
+    permissions:
+      id-token: write  # Wajib untuk OIDC Trusted Publishing ke PyPI
+      contents: read
+
+    steps:
+      - name: Checkout source code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install build dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install build
+
+      - name: Build binary wheel and source tarball
+        run: python -m build
+
+      - name: Publish package to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+

aleshaq_sdk-0.1.0/.gitignore

@@ -0,0 +1,32 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg-info/
+*.egg
+dist/
+build/
+.eggs/
+*.whl
+*.venv/
+venv/
+.env
+.venv
+env/
+
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+
+*.ipynb_checkpoints/
+.mypy_cache/
+.ruff_cache/
+
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+.DS_Store

aleshaq_sdk-0.1.0/LICENSE

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

aleshaq_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,200 @@
+Metadata-Version: 2.5
+Name: aleshaq-sdk
+Version: 0.1.0
+Summary: Aleshnatt Quantum SDK: Comprehensive toolkit for quantum primitives, error correction, networking, and protocols.
+Project-URL: Homepage, https://github.com/naufaziy/aleshaq
+Project-URL: Repository, https://github.com/naufaziy/aleshaq
+Author: Naufal Ziyaadaturrahman
+License: MIT License
+        
+        Copyright (c) 2026 Naufal Ziyaadaturrahman
+        
+        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.
+License-File: LICENSE
+Keywords: bb84,qec,qiskit,qkd,quantum,quantum-computing,quantum-cryptography,quantum-error-correction,quantum-information,quantum-networking,teleportation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Requires-Dist: qiskit>=2.0
+Provides-Extra: all
+Requires-Dist: qbraid>=0.6.0; extra == 'all'
+Requires-Dist: qiskit-aer; extra == 'all'
+Requires-Dist: qiskit-ibm-runtime>=0.18.0; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: qiskit-aer; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Provides-Extra: ibm
+Requires-Dist: qiskit-ibm-runtime>=0.18.0; extra == 'ibm'
+Provides-Extra: qbraid
+Requires-Dist: qbraid>=0.6.0; extra == 'qbraid'
+Provides-Extra: sim
+Requires-Dist: qiskit-aer; extra == 'sim'
+Description-Content-Type: text/markdown
+
+# Aleshnatt Quantum SDK (`aleshaq-sdk`)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python Version](https://img.shields.io/badge/python-3.9%2B-blue)](https://www.python.org/downloads/)
+[![Qiskit Compatibility](https://img.shields.io/badge/Qiskit-2.0%2B-6929C4.svg)](https://qiskit.org/)
+
+**Aleshnatt Quantum SDK** (`aleshaq`) is a modular, production-grade Python toolkit for quantum computing, quantum error correction, quantum networking, and quantum cryptographic protocols. Built natively on Qiskit.
+
+---
+
+## 📦 Architecture & Packages
+
+`aleshaq` unites the full quantum information stack into four cohesive modules:
+
+```text
+┌────────────────────────────────────────────────────────────────────────┐
+│                        aleshaq-sdk (Top-Level)                         │
+├────────────────────────────────────────────────────────────────────────┤
+│ 1. aleshaq.primitives  │ Bell/GHZ/W States, QFT, QPE, Oracles, Backend │
+├────────────────────────┼───────────────────────────────────────────────┤
+│ 2. aleshaq.qec         │ Stabilizers (Shor, Steane), Decoders, Noise   │
+├────────────────────────┼───────────────────────────────────────────────┤
+│ 3. aleshaq.networking  │ Nodes, Quantum Channels, Swapping, Routing    │
+├────────────────────────┼───────────────────────────────────────────────┤
+│ 4. aleshaq.protocols   │ QKD (BB84, B92, E91, Decoy), Teleportation    │
+└────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🚀 Installation
+
+```bash
+# Base SDK installation:
+pip install aleshaq-sdk
+
+# With local simulation (Qiskit Aer):
+pip install "aleshaq-sdk[sim]"
+
+# With hardware providers (IBM Quantum Runtime & qBraid):
+pip install "aleshaq-sdk[ibm]"
+pip install "aleshaq-sdk[qbraid]"
+
+# Complete installation with all dependencies:
+pip install "aleshaq-sdk[all]"
+```
+
+---
+
+## ⚡ Quick Start
+
+### 1. Quantum Primitives (`aleshaq.primitives`)
+
+```python
+from aleshaq.primitives import bell_state, ghz_state, qft, phase_estimation
+
+# Prepare a Bell state (|Φ⁺⟩) circuit
+qc_bell = bell_state(0)
+print(qc_bell)
+
+# Generate a 3-qubit Quantum Fourier Transform circuit
+qc_qft = qft(n_qubits=3, do_swaps=True)
+print(qc_qft)
+```
+
+### 2. Quantum Error Correction (`aleshaq.qec`)
+
+```python
+from aleshaq.qec import SteaneCode, LookupTableDecoder, extract_syndrome
+
+# Instantiate the 7-qubit Steane [[7,1,3]] code
+code = SteaneCode()
+encoder_circuit = code.encode()
+
+# Extract stabilizer syndromes
+syndrome_qc = code.syndrome_circuit()
+```
+
+### 3. Quantum Networking (`aleshaq.networking`)
+
+```python
+from aleshaq.networking import QuantumNetwork, Node
+from aleshaq.networking.protocols import EntanglementDistribution
+
+# Build a 3-node quantum network
+net = QuantumNetwork("Aleshnatt-Network")
+alice = Node("Alice", qubit_capacity=4)
+repeater = Node("Repeater", qubit_capacity=4)
+bob = Node("Bob", qubit_capacity=4)
+
+net.add_node(alice)
+net.add_node(repeater)
+net.add_node(bob)
+net.connect(alice, repeater, length_km=10.0)
+net.connect(repeater, bob, length_km=10.0)
+
+# Distribute entanglement over multi-hop routing
+dist = EntanglementDistribution(net)
+res = dist.distribute("Alice", "Bob")
+print(f"End-to-end fidelity: {res.fidelity:.4f}")
+```
+
+### 4. Quantum Protocols & Cryptography (`aleshaq.protocols`)
+
+```python
+from aleshaq.protocols import BB84, DecoyStateBB84, Teleportation
+
+# Run BB84 QKD Simulation
+bb84 = BB84(n_bits=500, eavesdropper_present=False, seed=42)
+result = bb84.run()
+print(f"Sifted key length: {len(result.sifted_key_alice)}, QBER: {result.qber}")
+
+# Run Decoy-State BB84 with Photon-Number Splitting (PNS) detection
+decoy = DecoyStateBB84(n_rounds=1000, mu=0.5, nu=0.1, simulate_pns_attack=False)
+decoy_res = decoy.run()
+print(f"PNS Attack Detected: {decoy_res.pns_attack_detected}")
+```
+
+---
+
+## 🛠️ Development & Testing
+
+```bash
+# Clone the repository
+git clone https://github.com/naufaziy/aleshaq.git
+cd aleshaq
+
+# Install in editable mode with development tools
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+---
+
+## 📄 License
+
+This project is licensed under the [MIT License](LICENSE).

aleshaq_sdk-0.1.0/README.md

@@ -0,0 +1,139 @@
+# Aleshnatt Quantum SDK (`aleshaq-sdk`)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python Version](https://img.shields.io/badge/python-3.9%2B-blue)](https://www.python.org/downloads/)
+[![Qiskit Compatibility](https://img.shields.io/badge/Qiskit-2.0%2B-6929C4.svg)](https://qiskit.org/)
+
+**Aleshnatt Quantum SDK** (`aleshaq`) is a modular, production-grade Python toolkit for quantum computing, quantum error correction, quantum networking, and quantum cryptographic protocols. Built natively on Qiskit.
+
+---
+
+## 📦 Architecture & Packages
+
+`aleshaq` unites the full quantum information stack into four cohesive modules:
+
+```text
+┌────────────────────────────────────────────────────────────────────────┐
+│                        aleshaq-sdk (Top-Level)                         │
+├────────────────────────────────────────────────────────────────────────┤
+│ 1. aleshaq.primitives  │ Bell/GHZ/W States, QFT, QPE, Oracles, Backend │
+├────────────────────────┼───────────────────────────────────────────────┤
+│ 2. aleshaq.qec         │ Stabilizers (Shor, Steane), Decoders, Noise   │
+├────────────────────────┼───────────────────────────────────────────────┤
+│ 3. aleshaq.networking  │ Nodes, Quantum Channels, Swapping, Routing    │
+├────────────────────────┼───────────────────────────────────────────────┤
+│ 4. aleshaq.protocols   │ QKD (BB84, B92, E91, Decoy), Teleportation    │
+└────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🚀 Installation
+
+```bash
+# Base SDK installation:
+pip install aleshaq-sdk
+
+# With local simulation (Qiskit Aer):
+pip install "aleshaq-sdk[sim]"
+
+# With hardware providers (IBM Quantum Runtime & qBraid):
+pip install "aleshaq-sdk[ibm]"
+pip install "aleshaq-sdk[qbraid]"
+
+# Complete installation with all dependencies:
+pip install "aleshaq-sdk[all]"
+```
+
+---
+
+## ⚡ Quick Start
+
+### 1. Quantum Primitives (`aleshaq.primitives`)
+
+```python
+from aleshaq.primitives import bell_state, ghz_state, qft, phase_estimation
+
+# Prepare a Bell state (|Φ⁺⟩) circuit
+qc_bell = bell_state(0)
+print(qc_bell)
+
+# Generate a 3-qubit Quantum Fourier Transform circuit
+qc_qft = qft(n_qubits=3, do_swaps=True)
+print(qc_qft)
+```
+
+### 2. Quantum Error Correction (`aleshaq.qec`)
+
+```python
+from aleshaq.qec import SteaneCode, LookupTableDecoder, extract_syndrome
+
+# Instantiate the 7-qubit Steane [[7,1,3]] code
+code = SteaneCode()
+encoder_circuit = code.encode()
+
+# Extract stabilizer syndromes
+syndrome_qc = code.syndrome_circuit()
+```
+
+### 3. Quantum Networking (`aleshaq.networking`)
+
+```python
+from aleshaq.networking import QuantumNetwork, Node
+from aleshaq.networking.protocols import EntanglementDistribution
+
+# Build a 3-node quantum network
+net = QuantumNetwork("Aleshnatt-Network")
+alice = Node("Alice", qubit_capacity=4)
+repeater = Node("Repeater", qubit_capacity=4)
+bob = Node("Bob", qubit_capacity=4)
+
+net.add_node(alice)
+net.add_node(repeater)
+net.add_node(bob)
+net.connect(alice, repeater, length_km=10.0)
+net.connect(repeater, bob, length_km=10.0)
+
+# Distribute entanglement over multi-hop routing
+dist = EntanglementDistribution(net)
+res = dist.distribute("Alice", "Bob")
+print(f"End-to-end fidelity: {res.fidelity:.4f}")
+```
+
+### 4. Quantum Protocols & Cryptography (`aleshaq.protocols`)
+
+```python
+from aleshaq.protocols import BB84, DecoyStateBB84, Teleportation
+
+# Run BB84 QKD Simulation
+bb84 = BB84(n_bits=500, eavesdropper_present=False, seed=42)
+result = bb84.run()
+print(f"Sifted key length: {len(result.sifted_key_alice)}, QBER: {result.qber}")
+
+# Run Decoy-State BB84 with Photon-Number Splitting (PNS) detection
+decoy = DecoyStateBB84(n_rounds=1000, mu=0.5, nu=0.1, simulate_pns_attack=False)
+decoy_res = decoy.run()
+print(f"PNS Attack Detected: {decoy_res.pns_attack_detected}")
+```
+
+---
+
+## 🛠️ Development & Testing
+
+```bash
+# Clone the repository
+git clone https://github.com/naufaziy/aleshaq.git
+cd aleshaq
+
+# Install in editable mode with development tools
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+---
+
+## 📄 License
+
+This project is licensed under the [MIT License](LICENSE).

aleshaq_sdk-0.1.0/examples/networking/entanglement_distribution.py

@@ -0,0 +1,33 @@
+"""Distribute entanglement across a multi-hop network."""
+
+from aleshaq.networking import Node
+from aleshaq.networking.entanglement import EntanglementManager
+from aleshaq.networking.routing import Topology
+from aleshaq.networking.protocols import EntanglementDistribution
+
+# Build a linear chain: A — B — C — D
+topology = Topology()
+nodes = [Node("A"), Node("B"), Node("C"), Node("D")]
+for n in nodes:
+    topology.add_node(n)
+for i in range(len(nodes) - 1):
+    topology.add_edge(nodes[i], nodes[i + 1])
+
+manager = EntanglementManager()
+
+# Each direct link has fidelity 0.95, each swap operation has fidelity 0.98
+protocol = EntanglementDistribution(
+    topology, manager,
+    link_fidelity=0.95,
+    swap_fidelity=0.98,
+)
+
+result = protocol.distribute(nodes[0], nodes[-1])
+
+print(f"Source: {result.source.name}")
+print(f"Destination: {result.destination.name}")
+print(f"Path: {[n.name for n in result.path]}")
+print(f"Success: {result.success}")
+if result.link:
+    print(f"End-to-end fidelity: {result.link.fidelity:.4f}")
+    print(f"Generation (swaps): {result.link.generation}")

aleshaq_sdk-0.1.0/examples/networking/simple_network.py

@@ -0,0 +1,23 @@
+"""Build a simple three-node quantum network and find paths."""
+
+from aleshaq.networking import QuantumNetwork, Node
+
+network = QuantumNetwork("example")
+
+alice = Node("alice")
+bob = Node("bob")
+charlie = Node("charlie")
+
+network.add_node(alice)
+network.add_node(bob)
+network.add_node(charlie)
+
+network.connect(alice, bob, loss_probability=0.05, length_km=50.0)
+network.connect(bob, charlie, loss_probability=0.08, length_km=80.0)
+
+print(f"Network nodes: {[n.name for n in network.nodes]}")
+print(f"Channels: {len(network.quantum_channels)}")
+
+path = network.find_path(alice, charlie)
+if path:
+    print(f"Path alice → charlie: {[n.name for n in path]}")

aleshaq_sdk-0.1.0/examples/primitives/bell_ibm_runtime.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""Prepare and measure Bell states on real IBM Quantum Runtime hardware.
+
+Requirements:
+    pip install "aleshaq-sdk[ibm]"
+    export QISKIT_IBM_TOKEN="your-ibm-quantum-api-token"
+"""
+
+import os
+import sys
+
+from qiskit import transpile
+
+from aleshaq.primitives import bell_state
+from aleshaq.primitives.exceptions import MissingCredentialsError
+from aleshaq.primitives.execution import get_ibm_backend
+
+
+def main() -> None:
+    token = os.environ.get("QISKIT_IBM_TOKEN") or os.environ.get("IBM_QUANTUM_TOKEN")
+    if not token:
+        print("=" * 70, file=sys.stderr)
+        print("ERROR: IBM Quantum credentials not found.", file=sys.stderr)
+        print("To run against real IBM Quantum hardware:", file=sys.stderr)
+        print("  1. Obtain an API token from https://quantum.ibm.com", file=sys.stderr)
+        print("  2. Set your environment variable:", file=sys.stderr)
+        print("       export QISKIT_IBM_TOKEN='<your_token>'", file=sys.stderr)
+        print("=" * 70, file=sys.stderr)
+        sys.exit(1)
+
+    print("Connecting to IBM Quantum Runtime...")
+    try:
+        backend_name = os.environ.get("QISKIT_IBM_BACKEND")
+        backend = get_ibm_backend(backend_name=backend_name, least_busy=not bool(backend_name), min_qubits=2)
+        print(f"Connected to IBM Quantum backend: {backend.name}")
+    except MissingCredentialsError as exc:
+        print(f"Authentication failed: {exc}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as exc:
+        print(f"Failed to connect to IBM Quantum: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    # 1. Prepare |Φ⁺⟩ Bell state circuit
+    qc = bell_state(0)
+    qc.measure_all()
+
+    # 2. Transpile and execute on hardware
+    print(f"\n--- Executing |Φ⁺⟩ Bell state circuit on {backend.name} ---")
+    t_qc = transpile(qc, backend)
+    job = backend.run(t_qc, shots=4096)
+    result = job.result()
+    counts = result.get_counts()
+
+    print("\n--- Measurement Counts ---")
+    print(counts)
+    p_00 = counts.get("00", 0) / 4096
+    p_11 = counts.get("11", 0) / 4096
+    print(f"Correlated pair fraction (|00⟩ + |11⟩): {p_00 + p_11:.2%}")
+
+
+if __name__ == "__main__":
+    main()

aleshaq_sdk-0.1.0/examples/primitives/bell_state.py

@@ -0,0 +1,15 @@
+"""Prepare and verify Bell states using aleshaq.primitives."""
+
+from qiskit_aer import AerSimulator
+from aleshaq.primitives.states import bell_state
+
+sim = AerSimulator()
+
+for pair in range(4):
+    circuit = bell_state(pair)
+    circuit.measure_all()
+
+    result = sim.run(circuit, shots=4096, seed_simulator=42).result()
+    counts = result.get_counts()
+
+    print(f"Bell state {circuit.name}: {counts}")

aleshaq_sdk-0.1.0/examples/primitives/phase_estimation.py

@@ -0,0 +1,35 @@
+"""Phase estimation example: estimate the eigenphase of the T gate.
+
+The T gate has eigenvalue e^{iπ/4} for eigenstate |1⟩, so the
+phase φ = 1/8.
+"""
+
+from qiskit.circuit import QuantumCircuit
+from qiskit_aer import AerSimulator
+
+from aleshaq.primitives.estimation import phase_estimation, interpret_phase
+
+# T gate as a unitary circuit
+t_gate = QuantumCircuit(1, name="T")
+t_gate.t(0)
+
+# Eigenstate |1⟩
+eigenstate = QuantumCircuit(1)
+eigenstate.x(0)
+
+# Build QPE circuit with 4 bits of precision
+qpe_circuit = phase_estimation(t_gate, precision=4, eigenstate_prep=eigenstate)
+print(f"QPE circuit: {qpe_circuit.num_qubits} qubits, depth {qpe_circuit.depth()}")
+
+# Run on simulator
+from qiskit import transpile
+sim = AerSimulator()
+transpiled_circuit = transpile(qpe_circuit, sim)
+result = sim.run(transpiled_circuit, shots=4096, seed_simulator=42).result()
+
+phases = interpret_phase(result.get_counts(), precision=4)
+for phase, count in sorted(phases.items(), key=lambda x: -x[1]):
+    print(f"  φ = {phase:.4f}  (count: {count})")
+
+dominant = max(phases, key=phases.get)
+print(f"\nEstimated phase: {dominant:.4f}  (expected: 0.1250)")

aleshaq_sdk-0.1.0/examples/primitives/qft.py

@@ -0,0 +1,33 @@
+"""Apply QFT and its inverse, verifying the roundtrip."""
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+from qiskit.quantum_info import Statevector
+
+from aleshaq.primitives.transforms import qft, inverse_qft
+
+n = 3
+
+# Start with a known computational basis state
+initial = QuantumCircuit(n)
+initial.x(0)  # |001⟩
+
+sv_initial = Statevector.from_instruction(initial)
+print(f"Initial state: {sv_initial}")
+
+# Apply QFT
+combined = QuantumCircuit(n)
+combined.compose(initial, inplace=True)
+combined.compose(qft(n), inplace=True)
+
+sv_transformed = Statevector.from_instruction(combined)
+print(f"After QFT: {sv_transformed}")
+
+# Apply inverse QFT — should recover the original state
+combined.compose(inverse_qft(n), inplace=True)
+
+sv_recovered = Statevector.from_instruction(combined)
+print(f"After QFT†: {sv_recovered}")
+
+fidelity = np.abs(np.vdot(sv_initial.data, sv_recovered.data)) ** 2
+print(f"Fidelity with initial state: {fidelity:.10f}")

aleshaq_sdk-0.1.0/examples/protocols/bb84.py

@@ -0,0 +1,12 @@
+"""BB84 QKD simulation example."""
+
+from aleshaq.protocols.cryptographic import BB84
+
+protocol = BB84(n_bits=100, seed=42)
+result = protocol.run()
+
+print(f"Total qubits sent: {len(result.alice_bits)}")
+print(f"Sifted key length: {len(result.sifted_key_alice)}")
+print(f"QBER: {result.qber:.4f}")
+print(f"Keys match: {result.sifted_key_alice == result.sifted_key_bob}")
+print(f"First 20 sifted key bits: {result.sifted_key_alice[:20]}")