abirqu

AbirQu Quantum SDK v1.2.4

Created by Abir Maheshwari  |  abhirsxn@gmail.com  |  aqdi.world  |  Indian Quantum Mission Support Enabled

---

What is AbirQu?

AbirQu is a comprehensive, hardware-independent quantum computing SDK with a full desktop IDE. It provides a single unified API across quantum computing, quantum communication, quantum error correction, hardware control, and a visual development environment — all implemented in pure NumPy with no vendor lock-in.

What makes AbirQu different

• Unified execution — QuantumRun does sampling, estimation, error mitigation, and ML in one call
• 12 hardware backends — IBM (verified on real ibm_fez hardware), IonQ, Rigetti, Quantinuum, AWS Braket, Azure Quantum, Google, D-Wave, SpinQ, Pasqal, OQC, QuEra
• 6 simulation engines — GPU (CuPy), Clifford (stabilizer tableau), MPS (tensor network), TTN (tree tensor network), Monte Carlo (quantum jumps), NumPy (portable fallback)
• Full transpiler pipeline — ML-enhanced with RL qubit routing + GNN layout, target-aware decomposition for 10 backends, SABRE routing, ASAP scheduling
• Quantum error correction — Surface/Color/Stabilizer codes, 6 decoders (MWPM, Union-Find, Belief Propagation, GPU-accelerated), magic state distillation, fault-tolerant compiler
• 7 QKD protocols — BB84, E91, CV-QKD, DI-QKD, satellite QKD, repeater chains, quantum networks
• 6 domain modules — Chemistry (VQE, Jordan-Wigner/Bravyi-Kitaev), OSINT (graph→Ising optimization), Cryptanalysis (Shor/Grover), Space (HHL solver), Q-PINN (quantum PDE solvers), Agentic orchestration
• AI/ML integration — MCP protocol for AI agents, LLM copilot (template-matching NL→circuit), PyTorch/JAX/TensorFlow quantum layers
• Production infrastructure — SQLite job queue, 4 scheduling policies, cost estimation, RBAC, audit trail, resource estimation
• 14-panel desktop IDE — Circuit editor, Python/QASM editors, file explorer, framework runner, QEC lab, quantum comm, domain modules, security, plugins, NL2Q, settings, Bloch sphere, results, console
• 8 language bindings — Python, JavaScript/TypeScript, Go, Java, .NET, Swift, Kotlin, WebAssembly
• 206 tutorials — comprehensive learning material from beginner to advanced

Built with

Python, NumPy, SciPy, Rust, TypeScript, React  |  Licensed under MIT 2026  |  Runs on Intel, AMD, Qualcomm, MediaTek, Apple Silicon — CPU and GPU  |  No vendor lock-in

┌─────────────────────────────────────────────────────────────────────┐
│                   AbirQu Desktop IDE (14 panels)                     │
│  Circuit Editor │ Python/QASM Editors │ Explorer │ Frameworks        │
│  QEC Lab │ Quantum Comm │ Domain Modules │ Security │ Plugins        │
│  Ask Quantum (NL2Q) │ Settings │ Bloch │ Results │ Console           │
├─────────────────────────────────────────────────────────────────────┤
│                      Core Engine                                     │
│  Circuit DSL │ Gate Matrices │ ML Transpiler │ Noise Toolkit         │
│  Auto-differentiation │ Dynamical Decoupling │ Resource Estimation   │
├─────────────────────────────────────────────────────────────────────┤
│  12 Hardware Backends      │  6 Simulation Engines                   │
│  IBM, IonQ, Rigetti,       │  GPU, Clifford, MPS, TTN,              │
│  Quantinuum, AWS, Azure,   │  Monte Carlo, NumPy                    │
│  Google, D-Wave, Pasqal,   │                                         │
│  OQC, QuEra, SpinQ         │                                         │
├─────────────────────────────────────────────────────────────────────┤
│  Quantum OS    │  QEC (Surface/Color/Stabilizer)                     │
│  Job Queue     │  6 Decoders (MWPM + Union-Find) │ Magic State       │
│  RBAC, Audit   │  Fault-Tolerant Compiler │ Resource Estimator       │
├─────────────────────────────────────────────────────────────────────┤
│  Domain Modules: Chemistry │ OSINT │ Crypto │ Space │ QPINN │ Agentic│
│  Quantum Communication: BB84 │ E91 │ CV-QKD │ DI-QKD                │
│  AI/ML: MCP Integration │ LLM Copilot │ PyTorch/JAX/TF Layers       │
│  Novel: Noise-Adaptive Compiler │ SPAE │ Circuit Cutting             │
└─────────────────────────────────────────────────────────────────────┘

---

What's Inside AbirQu

All modules use pure NumPy with OpenBLAS DYNAMIC_ARCH — runs on Intel, AMD, Qualcomm, MediaTek, and Apple Silicon without recompilation.

---

Comparison with Other SDKs

Tradeoff: AbirQu has broader scope (IDE, communication, QEC, domain modules). Qiskit/Cirq/Braket focus on production hardware execution — they do fewer things but do them at production scale.

---

Benchmarks

Real, reproducible benchmarks on local NumPy simulator (Intel, 64 threads):

---

Features

Core — Unified Execution

Circuit Library

12 Hardware Backends

Simulation Backends

Quantum Error Correction

6 Decoders: Syndrome Lookup, Surface-code MWPM, Belief Propagation, MWPM, GPU-Accelerated BP, Union-Find

Magic State Distillation: 15-to-1 T-state and 20-to-4 H-state distillers

Quantum Communication (7 Protocols)

Novel Contributions (Research Algorithms)

Additional Modules

Language Bindings

---

Desktop IDE — "VS Code for Quantum Computing"

Full-featured quantum IDE built with Tauri 2.x (Rust + React + TypeScript). Runs natively on Linux, macOS, and Windows.

Download Installers

All 14 Panels

IDE Features

• Resizable Panels — drag-to-resize splits for custom layouts
• Noise Simulation — depolarizing/amplitude/phase/readout noise with presets (IBM, Google, Heavy)
• Export Reports — HTML research reports, PDF (via browser print), OpenQASM, JSON
• Hardware Panel — 12 backends grouped by provider with status indicators
• Job Dashboard — real-time monitoring with progress bars and history
• Console — real-time output with color-coded lines
• Dark/Light Themes — CSS variable-based glassmorphism design

Build from Source

cd gui
npm install
npx @tauri-apps/cli build
# Binary: src-tauri/target/release/abirqu-gui
# Installers: src-tauri/target/release/bundle/

Install (Linux)

# Debian/Ubuntu
sudo dpkg -i AbirQu_1.2.4_amd64.deb

# Fedora/RHEL
sudo rpm -i AbirQu-1.2.4-1.x86_64.rpm

# Any Linux (portable)
chmod +x AbirQu_1.2.4_amd64.AppImage && ./AbirQu_1.2.4_amd64.AppImage

Install (Windows)

Download AbirQu_1.2.4_x64-setup.exe from Releases and run the installer.

Install (macOS)

Download AbirQu_1.2.4_aarch64.dmg (Apple Silicon) or AbirQu_1.2.4_x64.dmg (Intel) from Releases, open the DMG, and drag AbirQu to Applications.

Pre-built Binaries

All installers are built automatically via GitHub Actions on every push to master.

---

Installation

From PyPI (recommended)

pip install abirqu

With optional hardware support:

pip install abirqu[ibm]        # IBM Quantum hardware
pip install abirqu[dwave]      # D-Wave annealer
pip install abirqu[aws]        # AWS Braket
pip install abirqu[all-hardware] # All hardware backends
pip install abirqu[dev]        # Development tools

From Source

git clone https://github.com/Abiress/abirqu.git
cd abirqu
pip install -e .

System Requirements

Verify Installation

import abirqu
print(f"AbirQu version: {abirqu.__version__}")

from abirqu import Circuit
from abirqu.primitives import QuantumRun

circuit = Circuit(2)
circuit.h(0)
circuit.cnot(0, 1)
circuit.measure_all()

result = QuantumRun(circuit, shots=1000)
print(result.counts)  # {'00': ~500, '11': ~500}

Provider API Keys (for Real Hardware)

export IBM_QUANTUM_TOKEN="your_token_here"
export AWS_ACCESS_KEY_ID="your_key"
export AWS_SECRET_ACCESS_KEY="your_secret"
export AZURE_QUANTUM_RESOURCE_ID="your_resource_id"
export IONQ_API_KEY="your_key"
export GOOGLE_CLOUD_PROJECT="your_project_id"

---

Quick Start

Basic Circuit

from abirqu import Circuit
from abirqu.primitives import QuantumRun

circuit = Circuit(2)
circuit.h(0)
circuit.cnot(0, 1)
circuit.measure_all()

result = QuantumRun(circuit, shots=1000)
print(result.counts)  # {'00': ~500, '11': ~500}

Quantum Chemistry

from abirqu.chemistry import JordanWignerMapper

mapper = JordanWignerMapper(n_orbitals=2)
one_electron = [(0, 0, -1.0), (1, 1, -1.0)]
two_electron = [(0, 0, 0, 0, 0.5)]
qubit_terms = mapper.map_hamiltonian(one_electron, two_electron)
print(f"Qubit Hamiltonian terms: {len(qubit_terms)}")

Quantum Communication

from abirqu.quantum_communication import BB84Protocol

bb84 = BB84Protocol(num_bits=10)
result = bb84.run()
print(f"Final key: {result.final_key}")
print(f"QBER: {result.error_rate:.3f}")

Run on Real IBM Hardware

import os
if os.environ.get("IBM_QUANTUM_TOKEN"):
    from abirqu import Circuit
    from abirqu.backends.ibm import IBMQuantumBackend

    backend = IBMQuantumBackend(backend_name="ibm_fez")
    circuit = Circuit(2)
    circuit.h(0)
    circuit.cnot(0, 1)
    circuit.measure_all()
    result = backend.run_circuit(circuit, shots=100)
    print(result["counts"])
else:
    print("Set IBM_QUANTUM_TOKEN to run on real hardware")

---

Tutorials

205 tutorials covering quantum computing from basics to advanced:

Full index: tutorials/INDEX.md

---

Test Results

Platform:   x86_64 | Python 3.14.4 | NumPy 2.4.4
OpenBLAS:   DYNAMIC_ARCH (Haswell) — Intel/AMD compatible
CPU:        20 cores | 30.6 GB RAM

Test Files:
  test_gui.py              125 tests  (IDE backend components)
  test_comprehensive.py     83 tests  (core, backends, noise, chemistry, QEC)
  test_qec.py               83 tests  (all QEC codes + decoders)
  test_hardware.py          80 tests  (calibration, characterization, profiling)
  test_quantum_communication.py  30 tests  (BB84, E91, CV-QKD, DI-QKD)
  test_properties.py         9 tests  (quantum invariants)
  test_hybrid_simulator.py   6 tests  (hybrid Clifford/MPS)
  test_novel_contributions.py 5 tests  (novel algorithms)
  test_readme.py             1 test   (12 code blocks verified)
  test_tutorials.py          1 test   (tutorial validation)

---

Version History

---

What's Missing

Honest listing of areas for improvement:

• No peer review — no independent validation of results against literature values
• QEC decoders — MWPM decoder uses iterative greedy with re-weighting; production use requires PyMatching or blossom algorithm for optimal matching
• Pulse-level control — waveforms are generated but not sent to hardware
• IBM token required for hardware — IBM Quantum backend needs a real API token

---

Production & Enterprise Features

Custom Exception Hierarchy

from abirqu.exceptions import (
    AbirQuError,              # Base class
    CircuitError,             # Circuit construction errors
    SimulationError,          # Simulation failures
    BackendError,             # Hardware backend errors
    AuthenticationError,      # Missing/invalid credentials
    TranspilerError,          # Transpilation failures
    HardwareError,            # Hardware control errors
    JobError,                 # Job scheduling errors
    QuantumCommunicationError, # QKD protocol errors
    ConfigurationError,       # Configuration errors
)

Logging

from abirqu.logging_config import setup_logging
setup_logging(level="INFO")

Deprecation & API Stability

from abirqu._deprecated import deprecated, experimental

@deprecated("Use new_function() instead", since="1.2.0", removal="2.0.0")
def old_function(): pass

@experimental("This feature may change in v1.3.0")
def new_feature(): pass

Audit Trail

from abirqu.quantum_os.audit import AuditLogger
audit = AuditLogger()
audit.log_job_submit("job-123", "user@example.com", backend="ibm_brisbane", circuit_name="bell_state")
events = audit.get_events(user_id="user@example.com")

RBAC

from abirqu.quantum_os.rbac import RBACController
rbac = RBACController()
rbac.check_permission("user@example.com", "job.submit")
rbac.assign_role("user@example.com", "operator")

---

How This Compares

AbirQu is a production-grade, full-stack quantum SDK that covers:

• Unified execution — QuantumRun does sampling, estimation, error mitigation, and ML in one call
• 12 hardware backends — IBM (verified on real hardware), D-Wave, SpinQ, IonQ, Rigetti, Quantinuum, AWS, Azure, Google, Pasqal, OQC, QuEra
• 6 simulation engines — GPU, Clifford, MPS, TTN, Monte Carlo, NumPy
• Full transpiler pipeline — ML-enhanced (RL routing + GNN layout), target-aware decomposition, SWAP routing, fidelity estimation
• Noise mitigation — ZNE, readout mitigation, M3, PEC, adaptive error mitigation, dynamical decoupling
• QEC — Surface/Color/Stabilizer codes, 6 decoders (MWPM + Union-Find), magic state distillation
• 7 QKD protocols — BB84, E91, CV-QKD, DI-QKD, satellite, repeaters, network
• 6 domain modules — Chemistry, OSINT, Crypto, Space, QPINN, Agentic
• Post-quantum security — Kyber-768/1024 KEM, Dilithium-2/3/5 signatures, SPHINCS+-128f/256f signatures
• AI integration — MCP protocol, LLM copilot, PyTorch/JAX/TensorFlow layers
• Full desktop IDE — 14 panels, circuit editor, code editors, Bloch sphere, export reports
• 8 language bindings — Python, JavaScript, Go, Java, .NET, Swift, Kotlin, WebAssembly
• 206 tutorials — comprehensive learning material
• Resource estimation — Algorithm overhead + surface code cost model
• Cross-SDK converters — Import from Qiskit, Cirq, PennyLane

Compared to specialized SDKs:

• vs Qiskit: AbirQu has broader scope (communication, QEC, domain modules, IDE). Qiskit has deeper IBM hardware integration.
• vs Cirq: AbirQu supports 12 backends vs Cirq's Google focus. AbirQu includes QEC and domain modules.
• vs PennyLane: Both support differentiation. AbirQu includes hardware control, QEC, and a full IDE.
• vs Braket: AbirQu is hardware-independent (pure NumPy). Braket is AWS-focused.
• vs TKET: AbirQu includes domain modules, QEC, and a full IDE. TKET focuses on hardware-agnostic optimization.

Choose AbirQu when you need: a single SDK for quantum computing, communication, QEC, hardware control, and a visual development environment — all hardware-independent.

Choose a specialized SDK when you need: deep integration with a specific vendor's hardware features, or peer-reviewed algorithms for publication.

---

Known Limitations

---

Support

• Beginner Guide: abirqu/docs/beginner_guide.md
• 206 Tutorials: tutorials/INDEX.md
• Documentation: Readthedocs
• Whitepaper: docs/whitepaper.md
• Contributing: CONTRIBUTING.md
• Security: SECURITY.md
• PyPI: pypi.org/project/abirqu

---

Built with Python, NumPy, SciPy, Rust, TypeScript, React Licensed under MIT 2026 Runs on Intel, AMD, Qualcomm, MediaTek, Apple Silicon — CPU and GPU No vendor lock-in

---

2026 Abir Maheshwari — Artificial Quantum Dyson Intelligence, Biro Labs Made in India, for the World.