Metadata-Version: 2.4
Name: pktron
Version: 9.0.0
Summary: PKTron v6.1.6 — HPC Quantum Computing Framework
Home-page: https://github.com/paktronsimulatorpakistan
Author: CETQAC
Author-email: CETQAC <info@thecetqap.com>
License: MIT
Project-URL: Homepage, https://github.com/paktronsimulatorpakistan
Project-URL: Bug Tracker, https://github.com/paktronsimulatorpakistan/issues
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: home-page
Dynamic: requires-python

# PkTron Quantum HPC, QML, SDK, & Quantifiable Non-Equilibrium Metrics with The NEF (Noise & Error Free) Framework Simulator

### Top #1 in Asia and South Asia, Top 5 Globally (Based on Features, Modules and Breadth)

![Python](https://img.shields.io/badge/python-3.8%2B-blue)
![License](https://img.shields.io/badge/license-MIT-green)
![HPC](https://img.shields.io/badge/HPC-AVX--512%20%7C%20OpenMP%20%7C%20GPU-orange)
![SDK](https://img.shields.io/badge/SDK-Estimator%20%7C%20Sampler%20%7C%20Primitives-purple)
![Version](https://img.shields.io/badge/version-9.0.0-brightgreen)

**PKTron** is a full-stack quantum computing framework: a high-performance simulator, a quantum machine-learning toolkit, a hardware-aware SDK, and — new in v9.0.0 — two independent research systems: the **Non-Equilibrium (NEQ)** post-Born-rule metrics engine and the **NEF (Noise & Error Free)** five-layer mitigation framework. It ships **180+ public classes**, **60+ functions**, a compiled C statevector kernel (AVX-512/AVX2/OpenMP), optional GPU and MPI backends, and broad interoperability with Qiskit, Cirq, PennyLane, QASM3, Quil, IonQ and Braket.

Developed and maintained by **CETQAC — Centre of Excellence for Technology, Quantum and AI (Pakistan / Canada).**

```bash
pip install pktron            # core (numpy + scipy only)
pip install pktron[gpu]       # + CuPy GPU acceleration
pip install pktron[dev]       # + pytest, build, twine
```

```python
import pktron as pk

qc = pk.QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
result = pk.execute(qc, shots=1024)
print(result)            # Bell-state counts: ~50% '00', ~50% '11'
```

---

## Sample Circuits — Copy, Paste, Run

Every snippet below runs against the public `pktron` API exactly as installed from PyPI.

### 1. Bell state + measurement

```python
import pktron as pk

qc = pk.QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
counts = pk.execute(qc, shots=2048)
print(counts)
```

### 2. GHZ state (3 qubits)

```python
import pktron as pk

ghz = pk.QuantumCircuit(3)
ghz.h(0)
ghz.cx(0, 1)
ghz.cx(0, 2)
print(ghz.draw())                       # ASCII circuit diagram
sv = pk.StatevectorSimulator().run(ghz, shots=0)['statevector']
print("amplitudes:", sv)
```

### 3. VQE — ground-state energy

```python
import numpy as np, pktron as pk

H = np.array([[1, 0], [0, -1]], dtype=complex)   # single-qubit Z
res = pk.VQE(H).run(n_qubits=1)
print("ground-state energy:", res["energy"])      # → -1.0
```

### 4. Grover search

```python
import pktron as pk

grover = pk.GroverSearch(n_qubits=3, marked=[5])
res = grover.run()
print("found marked state:", res["found"])         # → 5
```

### 5. Zero-Noise Extrapolation (error mitigation)

```python
import numpy as np, pktron as pk

qc = pk.QuantumCircuit(3); qc.h(0); qc.cx(0, 1); qc.cx(0, 2)
obs = np.kron(np.array([[1, 0], [0, -1]]), np.eye(4))   # Z on qubit 0
executor = lambda c: pk.StatevectorSimulator().run(c, shots=0)
res = pk.ZeroNoiseExtrapolation().run(qc, executor, obs)
print("zero-noise value:", res["zero_noise_value"])
```

### 6. System I — Non-Equilibrium Mode (NEQ)  ★ new in v9.0.0

A post-Born-rule simulation engine. At coherence parameter `gamma = 0` it **recovers the exact Born rule**; as `gamma` grows it produces a controlled, fully quantified deviation.

```python
import pktron as pk

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

# Born recovery at gamma = 0
born = pk.NEQSimulator(pk.CoherenceWeighter("exponential", gamma=0.0)).run(ghz)
print("delta_neq (should be ~0):", born.delta_neq)
print("is Born-equivalent:", born.is_born_equivalent())

# Quantified non-equilibrium deviation at gamma = 0.5
neq = pk.NEQSimulator(pk.CoherenceWeighter("exponential", gamma=0.5)).run(ghz)
print("P_neq:", neq.p_neq)               # normalised post-Born distribution
print("delta_neq (TVD):", neq.delta_neq)
print("KL forward / reverse:", neq.kl_forward, neq.kl_reverse)
print("Hellinger:", neq.hellinger)
print("partition Z:", neq.partition_Z)

# Sweep gamma and analyse
scan = pk.NEQSimulator().scan_gamma(ghz, [0.0, 0.25, 0.5, 1.0])
print("delta_neq vs gamma:", [round(r.delta_neq, 4) for r in scan])

# Export full metrics as JSON
print(pk.DeviationAnalyzer(neq).export("json"))
```

### 7. System II — NEF (Noise & Error Free) Framework  ★ new in v9.0.0

An orchestrated five-layer mitigation pipeline — **DD → ZNE → PEC → CDR → Symmetry Verification** — that returns a fully itemised error budget.

```python
import numpy as np, pktron as pk

qc = pk.QuantumCircuit(2); qc.h(0); qc.cx(0, 1)
observable = np.kron(np.diag([1, -1]), np.eye(2))     # Z on qubit 0

# Run the full five-layer pipeline
result = pk.NoiseNullifier().run(qc, observable)
print("raw value:       ", result.raw_value)
print("mitigated value: ", result.mitigated_value)
print("layers applied:  ", result.layers_applied)     # ['dd','zne','pec','cdr','sv']
print("error budget:    ", result.error_budget)

# Configure / disable individual layers
cfg = pk.NEFConfig(enable_pec=False, enable_sv=False, dd_sequence="xy8")
print(pk.NoiseNullifier(cfg).run(qc, observable).layers_applied)   # ['dd','zne','cdr']

# Richardson extrapolation primitive (coefficients sum to 1)
rich = pk.RichardsonExtrapolator([1, 2, 3])
print("coefficients:", rich.coefficients)              # [3, -3, 1]

# Benchmark mitigated vs raw over several trials
print(pk.NoiseNullifier().benchmark(qc, observable, n_trials=5))
```

### 8. Compose both new systems on one circuit

```python
import numpy as np, pktron as pk

qc = pk.QuantumCircuit(3); qc.h(0); qc.cx(0, 1); qc.cx(0, 2)
obs = np.kron(np.array([[1, 0], [0, -1]]), np.eye(4))

neq = pk.NEQSimulator(pk.CoherenceWeighter("exponential", gamma=1.0)).run(qc)
nef = pk.NoiseNullifier().run(qc, obs)
print("NEQ partition Z:", neq.partition_Z)
print("NEF mitigated  :", nef.mitigated_value)
```

---

## Complete Feature & Module Reference

### Version history shipped in this release
`v4.0.0 → v4.0.4 → v5.0.1 → v6.0.0 → v6.1.6 → v7.0.0 → v8.0.0 → v8.0.1 → v9.0.0`

### Core module — `pktron/core.py`

**Simulators:** `StatevectorSimulator` (Clifford fast-path, auto-MPS routing, GPU fallback), `DensityMatrixSimulator`, `MPSSimulator`, `CliffordSimulator`, `UnitarySimulator`, `ExtendedStabilizerSimulator`, `SuperOpSimulator`.

**Circuit & execution:** `QuantumCircuit` (with `draw()`, `depth()`, all gate methods), `execute()`, `Gate`.

**Algorithms:** `VQE`, `GroverSearch`, `Shor`, `QuantumPhaseEstimation`, `HHLAlgorithm`, `SimonsAlgorithm`, `DeutschJozsa`, `QuantumWalk`, `QuantumAnnealing`.

**QML:** `QuantumNeuralNetwork`, `QuantumGAN`, `QuantumAutoencoder`, `QuantumCNN`, `QuantumBoltzmannMachine`, `QuantumFederatedLearning`, `QuantumTransferLearning`.

**Error correction:** `Steane7QEC`, `SurfaceCode` (arbitrary odd d ≥ 3), `ProbabilisticErrorCancellation`.

**Error mitigation:** `ZeroNoiseExtrapolation`, `ReadoutErrorMitigation`.

**Compilation & routing:** `SABRERouter`, `DynamicalDecoupling`.

**Chemistry & physics:** `QuantumChemistry` (H2, N2, CH4, CO2, NH3, C2H4).

**Cryptography:** `BB84Protocol`, `PostQuantumCrypto`.

**Benchmarking & noise:** `QuantumBenchmarking`, `NoiseModel`, `PauliError`.

### Additional modules (29 files)

- **`matchgate_sim.py`** — `MatchgateSimulator` (Gaussian fermionic / covariance-matrix simulation, O(n³)).
- **`dmrg.py`** — `DMRGSolver` (2-site DMRG for 1D Hamiltonians with MPO).
- **`fermionic_gaussian.py`** — `FermionicGaussianSimulator` (free-fermion quadratic Hamiltonians).
- **`qkd_pipeline.py`** — `QKDPipeline` (BB84, E91, B92, TwinField, MDI, DIQKD; sifting, privacy amplification; eavesdrop strategies; fiber-loss model).
- **`barren_plateau.py`** — `BarrenPlateauAnalyzer`.
- **`noise_aware_compile.py`** — `NoiseAwareCompiler`.
- **`qsvt.py`** — `QSVT`, `QSPAngleFinder`, `BlockEncoding`, `LinearCombinationBlockEncoding`.
- **`circuit_debugger.py`** — `QuantumCircuitDebugger` (gate-by-gate step-through).
- **`advanced_qml.py`** — `BarrenPlateauFreeQNN`, `QuantumKernelTrainer`, `QuantumMAML`, `ShotFrugalOptimizer`, `EstimatorQNN`, `SamplerQNN`.
- **`advanced_mitigation.py`** — `SymmetryVerification`, `ErrorAmplification`, `PauliNoiselearner`.
- **`advanced_crypto.py`** — `QuantumSecretSharing`, `BlindQuantumComputing`, `QuantumDigitalSignature`, `QuantumMoney`.
- **`advanced_algorithms.py`** — `QuantumMetropolis`, `LCU`, `QuantumSDP`, `AdiabaticOptimizer`, `PhaseKickback`.
- **`new_algorithms.py`** — `QuantumWalkSearch`, `VQITE`, `GRAPE`, `ParallelTemperingAnnealing`, `QuantumNAS`, `QuantumErrorLearning`.
- **`interop.py`** — `InteropConverter` (import Qiskit/Cirq/PennyLane; export QASM3/Quil/IonQ/Braket).
- **`config.py`** — `PKTronConfig`. **`validation.py`** — `QuantumStateValidator`. **`profiling.py`** — `PerformanceMonitor`.
- **`hardware_calibration.py`** — `CalibrationData`, `DeviceCalibration`. **`gate_scheduler.py`** — `GateSequence`, `TimingInfo`.
- **`noise_models.py`** — `NoiseModel` (ABC), `DepolarizingNoise`, `AmplitudeDamping`, `PhaseDamping`, `KrausChannel`, `NoiseModelBuilder`.
- **`drift_simulator.py`** — `DriftEngine`. **`dynamic_circuits.py`** — `DynamicCircuit`, `MidCircuitMeasurement`, `ConditionalGate`.
- **`hardware_report.py`** — `HardwareExecutionReport`. **`virtual_devices.py`** — `VirtualDevice`.
- **`multi_gpu_engine.py`** — `GPUScheduler`, `MultiGPUSimulator`.
- **`advanced.py`** — `UCCSDSolver`, `ADAPTVQESolver`, `VirtualDistillation`, `OpenQASM3Compiler`, `JAXOptimizer`, `AdaptiveMPSSimulator`, `SurfaceCodeDistance`.

### Transpiler / pass manager
`CouplingMap`, `TranspilerPass` (ABC), `BasicDecomposition`, `NoiseAdaptiveRouting`, `GateCancellation`, `PassManager`.

### Gradients / autodiff — `pktron/gradients.py`
`ParameterShiftGradient`, `QuantumNaturalGradient`, `SPSAOptimizer`, `make_gradient()`.

### ML framework integration
`TorchLayer`, `KerasLayer`, `JAXLayer`, `QNNCircuit`, `EstimatorQNN`, `SamplerQNN`.

### Primitives / runtime layer
`Estimator`, `Sampler`, `StatevectorEstimator`, `StatevectorSampler`, `NoisyEstimator`, `Session`, `Job`, `PrimitiveResult`.

### Observables / Pauli framework — `pktron/pauli.py`
`Pauli`, `PauliList`, `SparsePauliOp`, `PauliTerm`, `PauliSum`, `pauli_basis(n)`, `commutator()`, `anti_commutator()`.

### Chemistry expansion
`Molecule`, `ElectronicStructureProblem`, `HartreeFockInitialPoint`, `ActiveSpaceTransformer`, `FreezeCoreTransformer`, `Z2Symmetries`, `ParityMapper`, `BravyiKitaev`, `kUpCCGSD`, `PUCCD`, `SUCCD`, `EvolvedOperatorAnsatz`.

### Error-correction expansion
`SurfaceCode(distance=d)`, `BlossomVDecoder`, `PyMatchingDecoder`, `FaultTolerantCircuit`, `ColorCode(distance=d)`, `HeavyHexCode`, `ThresholdEstimator`.

### Error-mitigation expansion
`fold_gates_at_random()`, `fold_gates_from_left()`, `fold_global()`, `RichardsonExtrapolation(order)`, `ExponentialExtrapolation`, `PolyExpExtrapolation`.

### Pulse level
`PulseSchedule`, `DriveChannel`, `ControlChannel`, `MeasureChannel`, `GaussianPulse`, `DRAGPulse`, `ConstantPulse`, `GaussianSquarePulse`, `PulseSimulator`.

### Benchmarking expansion
`StandardRB`, `InterleavedRB`, `MirrorRB`, `XEB`, `CLOPS`, `ProcessTomography`, `StateTomography`, `GateTomography`.

### Interoperability
`QASM2Codec`, `QASM3Parser`, `QuilExporter`, `QiskitImporter`, `CirqImporter`, `PennyLaneImporter`, `IonQExporter`, `BraketExporter`, `QPYCodec`.

### Circuit construction & visualization
`RXGate`, `RYGate`, `RZGate`, `U3Gate`, `CCXGate`, `C3XGate`, `QuantumRegister`, `ClassicalRegister`, `InstructionSet`, `CircuitInstruction`; `CircuitDrawer` with `.draw(mode='text'|'unicode'|'mpl', ...)`.

### Decomposition — `pktron/decompose.py`
`euler_zyz()`, `kak_decompose()`, `HardwareBackend` helpers.

### HPC subsystem
- **`kernels/`** — C kernel (`sv_kernels.c`): AVX-512/AVX2/OpenMP gate application, probabilities, sampling, expectation, fusion; `KernelSet`, `load_kernels()`.
- **`scheduler/`** — gate normalization, 1-qubit fusion, Clifford detection; `build_schedule()`, `OpNode`.
- **`runtime/`** — `StatevectorRuntime` (schedule → Clifford/GPU/C-kernel/NumPy fallback).
- **`sparse/`** — `SparseHamiltonian`, `ising_hamiltonian()`, `heisenberg_hamiltonian()`, `from_dense()`, `expectation_pauli()`.
- **`cache/`** — `CircuitCache` (LRU + disk, SHA-256 hash). **`gpu/`** — `GPUBackend` (CuPy). **`distributed/`** — `DistributedSimulator` (MPI). **`benchmarks/`** — full benchmarking harness.

### Finance module — `pktron/finance/core.py`
`QuantumAmplitudeEstimation`, `QuantumPortfolioOptimizer`, `QuantumOptionPricer`, `QuantumCreditRisk`, `OptionsPricing`, `PortfolioOptimizer`, `MonteCarloVaR`, `AnomalyDetection`.

### Defense module — `pktron/defense/core.py`
`QuantumVRP`, `QuantumGameTheory`, `MissionScheduler`, `SwarmOptimizer`, `TargetDetection`, `QuantumCryptanalysis`.

### v7.0.0 modules (23 features)
- **`v7_simulators.py`** — `SparseStatevectorSimulator`, `DynamicCircuitSimulator`, `LindbladSolver`.
- **`v7_algebra.py`** — `SparsePauliOp`, `AdjointDifferentiator`, `NaturalGradient`.
- **`v7_compiler.py`** — `CommutationCancellationPass`, `TemplateOptimizationPass`, `DepthOptimizationPass`, `NativeGateDecomposition`, `QubitRemappingPass`, `optimize_circuit()`, `circuit_unitary()`.
- **`v7_qasm3.py`** — `qasm3_export()`, `qasm3_parse()`.
- **`v7_tomography.py`** — `StateTomography`, `ProcessTomography`, `GateSetTomography`.
- **`v7_mitigation.py`** — `CliffordDataRegression`, `PauliTwirling`, `SymmetryVerification`.
- **`v7_benchmarking.py`** — `RandomizedBenchmarking`, `InterleavedRB`, `SimultaneousRB`, `MirrorBenchmarking`.
- **`v7_noise.py`** — `DeviceNoiseModel`, `fake_ibm_nairobi()`, `CorrelatedCrosstalk`, `thermal_relaxation_kraus()`, `depolarizing_kraus()`.
- **`v7_resources.py`** — `FaultTolerantResourceEstimator`, `TCountOptimizer`.

### v8.0.0 modules (7 features)
`compile.py` → `NoiseAdaptiveTranspiler`; `verify.py` → `CircuitVerifier`; `diff.py` → `AdjointGradient`; `noiselearn.py` → `NoiseCharacterizer`; `resource.py` → `ResourceEstimator`; corrected `finance/` and `defense/` implementations.

### v8.0.1 frontier algorithms (10) — `pktron/algorithms_v801.py`
`QuantumLatticeSieving`, `QuantumMoneyVerifier`, `QuantumCopyProtection`, `IQPSampling`, `QuantumGravityHolographic`, `NonAbelianAnyonSimulator`, `QuantumNPOracle`, `FaultTolerantMetropolisSampling`, `QuantumFullyHomomorphicEncryption`, `CVQKDMetropolitanRouter`.

### v9.0.0 new systems (2)

**System I — Non-Equilibrium Mode — `pktron/neq.py`**
`NEQSimulator` (post-Born-rule engine, exact Born recovery at γ=0), `CoherenceWeighter` (`exponential`/`gaussian`/`polynomial`/`custom` modes), `NEQResult` (`p_neq`, `delta_neq`, `kl_forward`, `kl_reverse`, `hellinger`, `partition_Z`, `is_born_equivalent()`), `DeviationAnalyzer` (`deviation`, `kl_divergence`, `hellinger`, `export`). *Verified:* Born rule recovered exactly at γ=0 (δ_neq < 1e-10); TVD monotone in γ; KL and Hellinger metrics consistent.

**System II — Noise & Error Free Framework — `pktron/nef.py`**
`NoiseNullifier` (orchestrated five-layer pipeline: DD → ZNE → PEC → CDR → SymmetryVerification), `NEFConfig`, `NEFResult` (`raw_value`, `mitigated_value`, `error_budget`, `layers_applied`, `improvement_factor()`), `RichardsonExtrapolator` (coefficients verified to sum to 1), `nef.SymmetryVerification`. *Verified:* Richardson coefficients correct; noiseless circuits return exact expectation; noise suppression demonstrated.

---

## Summary count

| Category | Count |
|---|---|
| Python modules / files | 45+ |
| Public classes | 180+ |
| Public functions | 60+ |
| C-extension functions | 14 |
| QKD protocols | 6 |
| Interop targets | 8 |
| Error-mitigation methods | 12+ |
| Error-correction codes | 6 |
| Benchmarking protocols | 8 |
| Finance algorithms | 8 |
| Defense algorithms | 6 |
| v7 features | 23 |
| v8.0.0 features | 7 |
| v8.0.1 frontier algorithms | 10 |
| v9.0.0 new systems | 2 (NEQ + NEF) |

---

---

## How PKTron Compares (Breadth & Modules)

This comparison is scoped to **feature and module breadth shipped in the framework itself** — not performance, maturity, or hardware access. Marks reflect each framework's current capabilities.

**Legend:** ✅ built-in &nbsp;·&nbsp; ◐ partial / via companion package or extension &nbsp;·&nbsp; ⬜ not available

| Capability | **PKTron** | Qiskit | Cirq | PennyLane | Qulacs | TensorCircuit | TKET | Braket |
|---|---|---|---|---|---|---|---|---|
| Simulator backends (SV/DM/MPS/stabilizer/…) | ✅ 7 types | ✅ | ◐ SV+DM | ◐ SV+DM | ◐ SV+DM | ◐ TN+SV+DM | ◐ ext | ◐ cloud |
| GPU acceleration | ✅ | ✅ | ◐ | ✅ | ✅ | ✅ | ◐ | ◐ cloud |
| MPI / distributed | ✅ | ✅ | ⬜ | ◐ | ◐ | ◐ | ⬜ | ◐ cloud |
| Compiled C/C++ kernel | ✅ AVX-512 | ✅ | ✅ qsim | ✅ Lightning | ✅ | ◐ XLA | ✅ | ◐ |
| Quantum machine learning | ✅ | ✅ | ◐ TFQ | ✅ | ◐ | ✅ | ⬜ | ◐ |
| Quantum chemistry | ✅ | ✅ Nature | ◐ OpenFermion | ✅ qchem | ◐ | ◐ | ◐ | ⬜ |
| Quantum finance | ✅ | ✅ Finance | ⬜ | ⬜ | ⬜ | ⬜ | ⬜ | ⬜ |
| Defense / mission domain modules | ✅ | ⬜ | ⬜ | ⬜ | ⬜ | ⬜ | ⬜ | ⬜ |
| Error-correction codes | ✅ 6 codes | ◐ qec | ◐ | ◐ | ⬜ | ⬜ | ⬜ | ⬜ |
| Error mitigation | ✅ 12+ | ✅ | ◐ | ✅ | ⬜ | ◐ | ◐ | ◐ |
| Transpiler / routing | ✅ | ✅ | ✅ | ✅ | ◐ | ◐ | ✅ best-in-class | ◐ |
| Pulse-level control | ✅ | ✅ | ◐ | ◐ | ⬜ | ⬜ | ⬜ | ✅ |
| Benchmarking (RB/tomography/XEB) | ✅ 8 | ✅ | ◐ | ◐ | ⬜ | ⬜ | ◐ | ⬜ |
| Interop (QASM3/Quil/IonQ/Braket/…) | ✅ 8 targets | ✅ | ◐ | ✅ plugins | ◐ | ◐ | ✅ | ✅ |
| **NEQ — post-Born non-equilibrium metrics** | ✅ | ⬜ | ⬜ | ⬜ | ⬜ | ⬜ | ⬜ | ⬜ |
| **NEF — unified 5-layer mitigation object** | ✅ | ⬜ | ⬜ | ⬜ | ⬜ | ⬜ | ⬜ | ⬜ |
| Everything in one `pip install` | ✅ | ⬜ (split) | ⬜ | ◐ core+plugins | ✅ | ✅ | ◐ | ◐ |

| Context | **PKTron** | Qiskit | Cirq | PennyLane | Qulacs | TensorCircuit | TKET | Braket |
|---|---|---|---|---|---|---|---|---|
| Execution model | Simulation-first | Sim + QPU | Sim + QPU | Sim + QPU | Sim | Sim + cloud | Compiler + QPU | Cloud QPU |
| Maturity | Emerging | Established | Established | Established | Established | Growing | Established | Established |

**Takeaway:** PKTron is the only framework here that ships finance **and** defense domain modules, six error-correction codes, an eight-protocol benchmarking suite, and the **NEQ + NEF** systems — all in a single `pip install`. Qiskit matches PKTron on many rows, but only by combining several separate packages (Aer, Nature, Finance, Experiments); and no other framework provides NEQ post-Born metrics or a unified NEF mitigation object at all. This breadth across simulators, QML, chemistry, finance, defense, error correction, mitigation, and benchmarking is the basis for PKTron's standing on **features, modules, and breadth.**

## What's new in v9.0.0

- **System I — NEQ:** a quantifiable post-Born-rule simulation engine with tunable coherence weighting and full deviation metrics (TVD, forward/reverse KL, Hellinger, partition function), with exact Born recovery at γ=0.
- **System II — NEF:** a configurable five-layer error-mitigation pipeline returning an itemised error budget, sampling overhead, and post-selection rate.
- Both systems are fully wired into the top-level namespace and validated by 20 spec assertions plus an 8-step end-to-end integration test.

## License & citation

MIT License © CETQAC — Centre of Excellence for Technology, Quantum and AI (Pakistan / Canada).

```
@software{pktron2026,
  title  = {PKTron: Quantum HPC, QML, SDK & Non-Equilibrium Metrics with the NEF Framework},
  author = {CETQAC},
  year   = {2026},
  version = {9.0.0},
  url    = {https://github.com/paktronsimulatorpakistan}
}
```
