Metadata-Version: 2.4
Name: pktron
Version: 4.0.1
Summary: PKTron Quantum Simulator Framework — #1 in South Asia, #1 in Asia, Top 5 Globally
Home-page: https://github.com/cetqap/pktron
Author: CETQAP
Author-email: cetqap@pktron.io
License: MIT
Project-URL: Bug Tracker, https://github.com/cetqap/pktron/issues
Project-URL: Source, https://github.com/cetqap/pktron
Keywords: quantum,computing,simulation,VQE,QAOA,Grover,Shor,quantum-machine-learning,quantum-chemistry,quantum-error-correction,quantum-cryptography,QKD,quantum-finance,tensor-network,MPS,DMRG,surface-code,HPC,GPU,pktron
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Science/Research
Classifier: Intended Audience :: Education
Classifier: Topic :: Scientific/Engineering :: Physics
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: License :: OSI Approved :: MIT License
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: Operating System :: OS Independent
Requires-Python: >=3.8
Description-Content-Type: text/markdown
Requires-Dist: numpy>=1.20
Requires-Dist: scipy>=1.7
Provides-Extra: gpu
Requires-Dist: cupy-cuda12x>=11.0; extra == "gpu"
Provides-Extra: dev
Requires-Dist: pytest>=7.0; extra == "dev"
Requires-Dist: build>=0.10; extra == "dev"
Requires-Dist: twine>=4.0; extra == "dev"
Dynamic: author
Dynamic: author-email
Dynamic: classifier
Dynamic: description
Dynamic: description-content-type
Dynamic: home-page
Dynamic: keywords
Dynamic: license
Dynamic: project-url
Dynamic: provides-extra
Dynamic: requires-dist
Dynamic: requires-python
Dynamic: summary

# PKTron Quantum Simulator Framework

### 🏆 #1 in South Asia &nbsp;·&nbsp; #1 in Asia &nbsp;·&nbsp; Top 5 Globally
#### *(Based on Features, Modules, and Breadth)*

[![PyPI version](https://badge.fury.io/py/pktron.svg)](https://pypi.org/project/pktron/)
[![Python ≥3.8](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![HPC Ready](https://img.shields.io/badge/HPC-Ready-green.svg)]()
[![PyPI Downloads](https://img.shields.io/pypi/dm/pktron.svg)](https://pypi.org/project/pktron/)

---

## What is PKTron?

**PKTron v4.0.1** is Pakistan's premier open-source quantum computing simulation framework —
and one of the most feature-complete quantum simulators available anywhere in the world.
Built for researchers, educators, engineers, and quantum enthusiasts, PKTron brings together:

- **50+ core quantum classes** in a single unified API
- **25+ specialised modules** covering algorithms, chemistry, cryptography, machine learning, finance, and defence
- **HPC subsystem** with compiled C kernels, sparse ops, circuit cache, GPU backend, and distributed runtime
- **15+ physics-correct algorithm fixes** validated against analytical ground truth
- **Interoperability** with Qiskit, Cirq, PennyLane, OpenQASM 3, and Quil

> Developed and maintained by **CETQAP** (Centre of Excellence in Theoretical & Applied Quantum Physics).

---

## Installation

```bash
pip install pktron
```

```bash
# Optional: GPU / HPC extras
pip install pktron[gpu]
```

---

## Quick-Start Circuits

### 1 — Bell State (Entanglement)

```python
import pktron as pk

qc = pk.QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)

result = pk.StatevectorSimulator().run(qc, shots=1024)
print(result["counts"])   # {"00": ~512, "11": ~512}
```

### 2 — GHZ State (Multi-qubit Entanglement)

```python
qc = pk.QuantumCircuit(4)
qc.h(0)
for i in range(3):
    qc.cx(i, i + 1)

result = pk.StatevectorSimulator().run(qc, shots=2048)
print(result["counts"])   # only "0000" and "1111"
```

### 3 — Quantum Fourier Transform

```python
qft = pk.QuantumFourierTransform(n_qubits=4)
result = qft.run()
print(f"QFT unitary shape: {result['unitary'].shape}")
```

### 4 — Grover's Search

```python
grover = pk.GroverSearch(n_qubits=4, target_state="1010")
result = grover.run(shots=2048)
print(f"Found: {result['top_result']}  probability: {result['success_prob']:.3f}")
```

### 5 — Shor's Algorithm

```python
shor = pk.Shor(N=15)
result = shor.run()
print(f"Factors of 15: {result['factors']}")
```

### 6 — VQE (Variational Quantum Eigensolver)

```python
import numpy as np
from pktron.pauli import PauliSum, PauliTerm

# H2 molecule Hamiltonian
H = PauliSum([
    PauliTerm(-1.0523732, "I"),
    PauliTerm(0.3979374, "Z", [0]),
    PauliTerm(-0.3979374, "Z", [1]),
    PauliTerm(-0.0112801, "ZZ", [0, 1]),
    PauliTerm(0.1809312, "XX", [0, 1]),
])

vqe = pk.VQE(hamiltonian=H, n_qubits=2, n_layers=3)
result = vqe.run(max_iter=200)
print(f"Ground energy: {result['energy']:.6f} Ha")
```

### 7 — QAOA (Combinatorial Optimisation)

```python
# Max-Cut on a 4-node graph
edges = [(0,1), (1,2), (2,3), (3,0)]
qaoa = pk.QAOA(n_qubits=4, edges=edges, p=2)
result = qaoa.run(shots=4096)
print(f"Best cut: {result['best_solution']}  value: {result['best_value']}")
```

### 8 — Quantum Phase Estimation

```python
import numpy as np

theta = 0.25   # phase to estimate
U = np.array([[np.exp(2j * np.pi * theta), 0],
               [0, 1]], dtype=complex)
eigenstate = np.array([1.0, 0.0])

qpe = pk.QuantumPhaseEstimation()
result = qpe.run(unitary=U, eigenstate=eigenstate, n_ancilla=8)
print(f"Estimated phase: {result['phase_estimate']:.4f}")   # ≈ 0.2500
```

### 9 — Quantum Chemistry (BeH2 Hamiltonian)

```python
chem = pk.QuantumChemistry()
result = chem.build_beh2_hamiltonian()
print(f"BeH2 qubit Hamiltonian: {result['n_qubits']} qubits")
print(f"Mapping: {result['mapping']}")   # Bravyi-Kitaev
```

### 10 — BB84 Quantum Key Distribution

```python
bb84 = pk.BB84Protocol(n_bits=256, noise_rate=0.02)
result = bb84.run()
print(f"Key rate: {result['key_rate']:.3f}")
print(f"QBER:     {result['qber']:.4f}")
print(f"Secure:   {result['is_secure']}")
```

### 11 — Density Matrix + Noise

```python
dm_sim = pk.DensityMatrixSimulator()
noise  = pk.NoiseModel()
noise.add_depolarizing(p=0.01)
noise.add_amplitude_damping(gamma=0.005)

qc = pk.QuantumCircuit(2)
qc.h(0); qc.cx(0, 1)

result = dm_sim.run(qc, noise_model=noise, shots=2048)
print(result["counts"])
```

### 12 — MPS Simulator (Large Circuits)

```python
mps = pk.MPSSimulator(max_bond_dim=64)
qc  = pk.QuantumCircuit(20)
for i in range(20):
    qc.h(i)
for i in range(19):
    qc.cx(i, i + 1)

result = mps.run(qc, shots=1024)
print(f"MPS bond dims: {result.get('bond_dims')}")
```

### 13 — Surface Code QEC

```python
sc = pk.SurfaceCode(distance=5)
result = sc.encode_logical_zero()
print(f"Logical qubits: {result['n_logical']}")
print(f"Code rate:      {result['code_rate']:.4f}")

dist = pk.SurfaceCodeDistance()
p_L  = dist.logical_error_rate(noise_rate=0.005, distance=5)
print(f"Logical error rate at d=5: {p_L:.2e}")
```

### 14 — DMRG Ground State

```python
solver = pk.DMRGSolver.from_ising(n_sites=12, J=1.0, g=0.5, bond_dim=64)
result = solver.run()
print(f"Ground energy:  {result['ground_energy']:.8f}")
print(f"Entanglement:   {result['entanglement_entropy']:.4f}")
```

### 15 — Quantum Finance

```python
from pktron.finance import QuantumPortfolioOptimizer, QuantumMonteCarlo

# Portfolio optimisation
opt = QuantumPortfolioOptimizer(n_assets=6)
result = opt.run(expected_returns=[0.1, 0.15, 0.08, 0.12, 0.09, 0.14],
                 risk_matrix="auto", budget=1.0)
print(f"Optimal portfolio: {result['weights']}")

# Monte Carlo pricing
mc = QuantumMonteCarlo(n_qubits=8)
result = mc.price_option(S0=100, K=105, T=1.0, r=0.05, sigma=0.2, n_samples=512)
print(f"Option price: {result['price']:.4f}")
```

### 16 — Quantum Defence & Logistics

```python
from pktron.defense import QuantumVRP, QuantumSwarmOptimizer

# Vehicle routing
vrp = QuantumVRP(n_cities=8, n_vehicles=2)
result = vrp.run()
print(f"Best route cost: {result['best_cost']:.2f}")

# Swarm optimisation
swarm = QuantumSwarmOptimizer(n_agents=16, n_qubits=6)
result = swarm.run(objective="coverage")
print(f"Swarm fitness: {result['fitness']:.4f}")
```

### 17 — Hardware Backend

```python
backend = pk.HardwareBackend(n_qubits=5, backend_name="pktron_hpc")
print(backend.backend_info())

qc = pk.QuantumCircuit(2)
qc.h(0); qc.cx(0, 1)
transpiled = backend.transpile(qc)
result = backend.run(transpiled, shots=2048)
print(result["counts"])
```

### 18 — Zero-Noise Extrapolation

```python
zne = pk.ZeroNoiseExtrapolation()
qc  = pk.QuantumCircuit(3)
qc.h(0); qc.cx(0, 1); qc.cx(1, 2)

result = zne.run(qc, noise_levels=[1, 2, 3], observable="Z0")
print(f"Mitigated expectation: {result['mitigated_value']:.6f}")
```

---

## Full Feature Reference

### Core Simulators (pktron.core)

| Class | Description |
|---|---|
| `QuantumCircuit` | Gate-model circuit builder with 23-gate native set |
| `StatevectorSimulator` | Exact statevector simulation up to ~28 qubits |
| `DensityMatrixSimulator` | Mixed-state / open-system simulation with Kraus maps |
| `MPSSimulator` | Matrix Product State for 50+ qubit circuits |
| `AdaptiveMPSSimulator` | Auto-selects bond dimension based on entanglement |
| `PEPSSimulator` | 2-D Tensor Network (PEPS) simulator |
| `MERASimulator` | Multi-scale Entanglement Renormalisation Ansatz |
| `TensorNetworkSimulator` | General tensor network contraction engine |
| `CliffordSimulator` | Stabiliser formalism — millions of qubits |
| `PulseLevelSimulator` | Microwave pulse-level Hamiltonian simulation |

### Gate Set

`H  X  Y  Z  S  T  Rx  Ry  Rz  CNOT  CZ  SWAP  iSWAP  CCX  CSWAP  CRz  Rzz  Rxx  Ryy  DCX  ECR  U3`

Plus: parametric gates, barrier, mid-circuit measurement, conditional gates, custom unitary injection.

### Core Algorithms (50 classes in core.py)

| Class | Algorithm |
|---|---|
| `GroverSearch` | Amplitude amplification, real oracle+diffusion circuit |
| `Shor` | QPE-based period finding & classical post-processing |
| `VQE` | Variational Quantum Eigensolver with PauliSum support |
| `QAOA` | Quantum Approximate Optimisation (p layers) |
| `HHLAlgorithm` | Harrow-Hassidim-Lloyd linear systems |
| `QuantumPhaseEstimation` | QPE with IQFT, 8-ancilla precision |
| `SimonsAlgorithm` | Simon's hidden subgroup (GF2 reliable) |
| `DeutschJozsa` | Deutsch-Jozsa oracle algorithm |
| `QuantumFourierTransform` | QFT unitary and circuit |
| `AmplitudeAmplification` | Generalised AA framework |
| `QuantumCounting` | QPE-based counting |
| `QuantumWalk` | Discrete quantum walk |
| `QuantumAnnealing` | Simulated quantum annealing |
| `QuantumChemistry` | BeH2/H2 Hamiltonians, Bravyi-Kitaev mapping |
| `QuantumNeuralNetwork` | Parametric QNN with analytic gradients |
| `QSVM` | Quantum Support Vector Machine |
| `QuantumGAN` | Quantum Generative Adversarial Network |
| `QuantumAutoencoder` | Quantum data compression |
| `QuantumCNN` | Quantum Convolutional Neural Network |
| `QuantumBoltzmannMachine` | Quantum Boltzmann learning |
| `QuantumFederatedLearning` | Federated quantum ML |
| `QuantumReinforcementLearning` | Quantum RL agent |
| `QuantumTransferLearning` | Domain-adaptation quantum model |
| `BB84Protocol` | QKD with realistic noise and QBER |
| `PostQuantumCrypto` | Lattice/hash-based PQC primitives |
| `ZeroNoiseExtrapolation` | Noise extrapolation error mitigation |
| `ProbabilisticErrorCancellation` | PEC error mitigation |
| `CliffordDataRegression` | CDR error mitigation |
| `ReadoutErrorMitigation` | Confusion matrix inversion |
| `DynamicalDecoupling` | DD sequence insertion |
| `SABRERouter` | SWAP-based qubit routing |
| `Steane7QEC` | Steane [[7,1,3]] code |
| `SurfaceCode` | Surface code encode/decode |
| `SurfaceCodeDistance` | MWPM logical error rate (physics-correct) |
| `BaconShorCode` | Bacon-Shor subsystem code |
| `ColorCode` | Topological colour code |
| `RepetitionCode` | Classical-analogy repetition code |
| `DRAGPulse` | DRAG pulse shape |
| `CrossResonancePulse` | Cross-resonance pulse |
| `HardwareBackend` | Unified hardware/transpile interface |
| `QuantumBenchmarking` | QV, RB, XEB, CLOPS benchmarks |
| `MultiGPUSimulator` | Distributed GPU statevector |

### Specialised Modules

| Module | Key Classes | Highlights |
|---|---|---|
| `pktron.matchgate_sim` | `MatchgateSimulator` | Exact Pfaffian/Slater-determinant sampling ≤10 qubits |
| `pktron.dmrg` | `DMRGSolver` | Ising/Heisenberg ground state, exact einsum contraction |
| `pktron.fermionic_gaussian` | `FermionicGaussianSimulator` | Gaussian fermionic states via covariance matrix |
| `pktron.qkd_pipeline` | `QKDPipeline` | BB84, E91, B92, TF-QKD, MDI-QKD, DIQKD |
| `pktron.barren_plateau` | `BarrenPlateauAnalyzer` | Gradient variance landscape analysis |
| `pktron.noise_aware_compile` | `NoiseAwareCompiler` | Hardware-noise-aware gate decomposition |
| `pktron.qsvt` | `QSVT` | Quantum Singular Value Transformation |
| `pktron.circuit_debugger` | `QuantumCircuitDebugger` | State inspection, gate-by-gate stepping |
| `pktron.circuit_drawing` | `CircuitDrawer` | ASCII + Unicode circuit diagrams |
| `pktron.gradients` | `ParameterShiftGradient`, `QuantumNaturalGradient`, `SPSAOptimizer` | Analytic & stochastic gradients |
| `pktron.pauli` | `PauliTerm`, `PauliSum` | Sparse Pauli operator algebra |
| `pktron.decompose` | — | KAK / Euler single-qubit decomposition |
| `pktron.interop` | `InteropConverter` | Export to Qiskit, Cirq, PennyLane, QASM3, Quil |
| `pktron.advanced_qml` | `BarrenPlateauFreeQNN`, `QuantumKernelTrainer`, `QuantumMetaLearner`, `ShotFrugalOptimizer` | Advanced QML algorithms |
| `pktron.advanced_mitigation` | `SymmetryVerification`, `ProbabilisticErrorAmplification`, `PauliNoiseLearner` | Advanced error mitigation |
| `pktron.advanced_crypto` | `QuantumSecretSharing`, `BlindQuantumComputing`, `QuantumDigitalSignature`, `QuantumMoney` | Quantum cryptography protocols |
| `pktron.advanced_algorithms` | `QuantumMetropolis`, `LCUFramework`, `QuantumSDP`, `AdiabticQuantumOptimizer`, `QuantumPhaseKickback` | Advanced quantum algorithms |
| `pktron.new_algorithms` | `QuantumWalkSearch`, `VariationalQuantumEigensolver2`, `QuantumOptimalControl`, `QuantumNeuralArchitectureSearch`, `QuantumErrorLearning` | Cutting-edge algorithms |
| `pktron.finance` | `QuantumPortfolioOptimizer`, `QuantumOptionPricer`, `QuantumMonteCarlo`, `QuantumCreditRisk`, `QuantumAmplitudeEstimation`, `QuantumAnomalyDetection` | Quantum finance & risk |
| `pktron.defense` | `QuantumVRP`, `QuantumGameTheory`, `QuantumMissionScheduler`, `QuantumSwarmOptimizer`, `QuantumTargetDetection`, `QuantumCryptanalysis` | Quantum defence & logistics |

### Hardware & Noise Modules

| Module | Key Classes | Description |
|---|---|---|
| `pktron.hardware_calibration` | `QubitCalibration`, `DeviceCalibration`, `CalibrationData` | T1/T2/gate-fidelity/readout calibration |
| `pktron.noise_models` | `NoiseModel`, `DepolarizingNoise`, `AmplitudeDamping`, `PhaseDamping`, `CrosstalkNoiseModel`, `ThermalNoiseModel` | Full Kraus-channel noise library |
| `pktron.gate_scheduler` | `GateScheduler`, `GateSequence`, `TimingInfo` | Pulse-level gate timing & scheduling |
| `pktron.drift_simulator` | `DriftEngine`, `CalibrationDriftSimulator` | Time-varying parameter drift |
| `pktron.dynamic_circuits` | `DynamicCircuit`, `MidCircuitMeasurement`, `ConditionalGate` | Mid-circuit measurement & feed-forward |
| `pktron.virtual_devices` | `VirtualDevice` | Mock hardware backends for testing |
| `pktron.hardware_report` | `HardwareExecutionReport` | JSON calibration & execution reports |
| `pktron.multi_gpu_engine` | `MultiGPUSimulator`, `GPUScheduler` | Multi-GPU distributed statevector |

### Advanced Algorithms Module (`pktron.advanced`)

| Class | Description |
|---|---|
| `UCCSDSolver` | Unitary Coupled Cluster Singles & Doubles for chemistry |
| `ADAPTVQESolver` | Adaptive VQE operator growth |
| `VirtualDistillation` | Error mitigation via virtual distillation |
| `OpenQASM3` | Full OpenQASM 3.0 export/import |
| `JAXOptimizer` | JAX-accelerated gradient optimiser |
| `SurfaceCodeDistance` | Physics-correct MWPM logical error rate |
| `AdaptiveMPSSimulator` | Entanglement-adaptive MPS |

### HPC Subsystem (`pktron.kernels`, `pktron.runtime`, etc.)

| Subpackage | Key Class | Description |
|---|---|---|
| `pktron.kernels` | `KernelSet` | Compiled C statevector kernels (AVX/SSE) |
| `pktron.runtime` | `StatevectorRuntime` | Multi-backend execution engine |
| `pktron.scheduler` | `Schedule`, `OpNode` | DAG-based operation scheduling |
| `pktron.sparse` | `SparseHamiltonian`, `PauliTerm` | Sparse Pauli Hamiltonian operations |
| `pktron.cache` | `CircuitCache` | LRU + disk circuit compilation cache |
| `pktron.gpu` | `GPUBackend` | GPU statevector backend |
| `pktron.distributed` | `DistributedRuntime` | Multi-node distributed simulation |
| `pktron.benchmarks` | `BenchResult` | QV, RB, XEB, CLOPS benchmark harness |
| `pktron.modular_backends` | `BackendRegistry`, `BackendPlugin` | Plugin-based backend registry |

### Utilities

| Module | Key Classes | Description |
|---|---|---|
| `pktron.config` | `PKTronConfig` | `reproducible / high_precision / fast` presets |
| `pktron.validation` | `QuantumStateValidator` | Statevector/Hermitian/unitary/density checks |
| `pktron.profiling` | `PerformanceMonitor` | Wall-time + memory profiling decorator |

---

## Backends

| Backend | Description | Best For |
|---|---|---|
| `StatevectorSimulator` | Exact full-statevector | ≤28 qubits, benchmarking |
| `DensityMatrixSimulator` | Mixed-state with Kraus noise | Noise characterisation |
| `MPSSimulator` | Matrix Product State | 20–100 qubit chains |
| `AdaptiveMPSSimulator` | Auto bond-dim MPS | Unknown entanglement structure |
| `PEPSSimulator` | 2-D tensor network | 2-D lattice circuits |
| `MERASimulator` | MERA | Critical/hierarchical systems |
| `CliffordSimulator` | Stabiliser tableau | Clifford circuits, millions of qubits |
| `PulseLevelSimulator` | Time-domain Lindblad | Pulse calibration & leakage |
| `MultiGPUSimulator` | Distributed GPU statevector | Large HPC clusters |
| `DistributedRuntime` | Multi-node MPI-style | Supercomputer-scale |
| `GPUBackend` | Single-GPU statevector | GPU workstations |
| `HardwareBackend` | Physical / mock device | Cloud & on-prem hardware |
| `StatevectorRuntime` (HPC) | C-kernel statevector | Maximum single-node speed |

---

## Interoperability

```python
from pktron.interop import InteropConverter

qc = pk.QuantumCircuit(2)
qc.h(0); qc.cx(0, 1)

conv = InteropConverter()
print(conv.to_qiskit(qc))       # Qiskit QuantumCircuit
print(conv.to_cirq(qc))         # Cirq Circuit
print(conv.to_pennylane(qc))    # PennyLane tape
print(conv.to_qasm3(qc))        # OpenQASM 3.0 string
print(conv.to_quil(qc))         # Quil string
```

---

## Error Mitigation

```python
# Zero-Noise Extrapolation
zne = pk.ZeroNoiseExtrapolation()

# Probabilistic Error Cancellation
pec = pk.ProbabilisticErrorCancellation()

# Clifford Data Regression
cdr = pk.CliffordDataRegression()

# Readout Error Mitigation
rem = pk.ReadoutErrorMitigation(n_qubits=5)

# Symmetry Verification
from pktron.advanced_mitigation import SymmetryVerification
sv = SymmetryVerification()
```

---

## Benchmarking

```python
from pktron.benchmarks import run_all

results = run_all(quick=True)
print(f"Quantum Volume:  {results['qv']}")
print(f"CLOPS:           {results['clops']:.0f}")
print(f"RB Fidelity:     {results['rb_fidelity']:.4f}")
print(f"XEB Score:       {results['xeb']:.4f}")
```

---

## Configuration

```python
import pktron as pk

# Reproducible research
pk.set_config(pk.PKTronConfig.reproducible(seed=42))

# High precision numerics
pk.set_config(pk.PKTronConfig.high_precision())

# Fast simulation (reduced precision)
pk.set_config(pk.PKTronConfig.fast())
```

---

## Module Count Summary

| Category | Modules | Classes |
|---|---|---|
| Core simulators & algorithms | 1 | 50+ |
| Specialised algorithms | 8 | 30+ |
| QML & optimisation | 3 | 12+ |
| Cryptography & QKD | 2 | 10+ |
| Hardware & noise | 8 | 20+ |
| Finance | 1 | 6 |
| Defence & logistics | 1 | 6 |
| HPC subsystem | 8 | 12+ |
| Utilities & interop | 5 | 10+ |
| **TOTAL** | **37+** | **156+** |

---

## Why PKTron Ranks #1 in Asia

| Feature | PKTron v4.0.1 | Typical alternatives |
|---|---|---|
| Native gate set | 23 gates | 10–15 gates |
| Simulator backends | 13 | 3–5 |
| QML algorithms | 10+ | 2–4 |
| QKD protocols | 6 (BB84→DIQKD) | 1–2 |
| QEC codes | 5 (Surface, Steane, Bacon-Shor, Color, Rep) | 1–2 |
| Error mitigation | 5 (ZNE, PEC, CDR, REM, SV) | 1–2 |
| Finance module | ✅ 6 classes | ✗ |
| Defence module | ✅ 6 classes | ✗ |
| HPC C kernel | ✅ | ✗ |
| GPU backend | ✅ | Optional/paid |
| Distributed sim | ✅ | ✗ or paid |
| Interop targets | 5 (Qiskit, Cirq, PL, QASM3, Quil) | 1–2 |
| Pulse-level sim | ✅ | Rarely |
| DMRG solver | ✅ | ✗ |
| MERA/PEPS | ✅ | Rarely |
| Physics-validated fixes | 15+ | N/A |
| Open source | ✅ MIT | Often proprietary |

---

## License

MIT License — Copyright © 2024–2026 CETQAP
