pktron 6.1.6

PKTron v6.1.6 — HPC Quantum Computing Framework

PkTron Quantum HPC & SDK Simulator

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

✨ Downloads more than 10K

---

What is PkTron?

PkTron v6.1.6 is a unified Quantum HPC + SDK Simulator framework — one of the most feature-complete quantum computing platforms available anywhere in the world, with over 10,000 downloads on PyPI.

A single pip install pktron gives you:

• 13 simulator backends (statevector, density matrix, MPS, Clifford, MERA, PEPS, tensor network, multi-GPU, distributed, pulse, trajectory, superoperator, matchgate, fermionic-Gaussian)
• 50+ quantum algorithms (Grover, Shor, QPE, QFT, HHL, VQE, QAOA, Simon, Deutsch–Jozsa, quantum walks, QSVT, amplitude amplification, quantum counting, adiabatic, Metropolis, SDP, NAS, GRAPE)
• Full HPC subsystem with compiled C kernels (AVX-512/AVX2/SSE/OpenMP), GPU runtime, MPI distributed runtime, circuit cache, and tensor-network kernels
• Complete quantum SDK — circuit construction, transpilation, serialization (QPY, QASM2/3, Quil, IonQ, Braket), interop (Qiskit, Cirq, PennyLane)
• Quantum chemistry stack — UCCSD, ADAPT-VQE, molecular Hamiltonians, fermionic mappers (JW, Parity, Bravyi–Kitaev)
• 6 error-correction codes (Steane, Surface, Bacon–Shor, Color, Repetition, Heavy-Hex) with MWPM / PyMatching decoders
• 7+ error-mitigation methods (ZNE, PEC, CDR, M3, dynamical decoupling, twirling, symmetry verification, probabilistic error amplification, virtual distillation)
• 10+ quantum ML algorithms (QNN, QSVM, QGAN, QCNN, QBM, QRL, transfer learning, federated learning, barren-plateau-free QNN, kernel trainer, meta-learner)
• Quantum cryptography — BB84, E91, B92, TF-QKD, MDI-QKD, DI-QKD, post-quantum primitives, blind quantum computing, quantum money, digital signatures
• Finance & Defense industry modules — portfolio optimization, option pricing, VaR/ES, anomaly detection, VRP, mission scheduling, swarm optimization, cryptanalysis
• Full interoperability with Qiskit, Cirq, PennyLane, OpenQASM 2/3, Quil, IonQ, Braket

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

---

What's new in v6.1.6

This release adds 10 HPC / SDK capabilities (a pure upgrade — nothing removed):

Class / function	What it does
pk.cuStateVec (CuStateVecBackend)	NVIDIA cuQuantum cuStateVec GPU statevector backend. Uses the GPU automatically when CUDA + cuQuantum are present, with transparent cupy and CPU fallbacks so the same code runs anywhere.
pk.cuTensorNet (CuTensorNetBackend)	NVIDIA cuQuantum cuTensorNet tensor-network contraction backend, falling back to the bundled MPS engine.
pk.GPUSampler / pk.GPUEstimator	GPU-accelerated Sampler/Estimator primitives built on the cuStateVec backend (CPU fallback included).
pk.auto_select_method / pk.AutoBackend	Automatic simulation-method selection (Clifford->stabilizer, large low-entanglement->MPS, GPU when available, else statevector), mirroring Aer's method="automatic".
pk.GateFusionPass	Transpiler-level gate-fusion pass that fuses runs of single-qubit gates into unitary blocks (verified exact; ~50%+ fewer gates).
pk.UnitarySynthesis	Synthesise an arbitrary 1- or 2-qubit unitary into native gates (exact), with OneQubitEulerDecomposer and TwoQubitBasisDecomposer.
pk.SolovayKitaev	Solovay-Kitaev decomposition approximating any 1-qubit unitary with a discrete {H, T, T-dg, S, S-dg} gate set to a chosen depth.
pk.DynamicsBackend	Pulse-level time-dynamics simulation solving the time-dependent Schrodinger equation (JAX integration when available, NumPy RK4 otherwise); validated against the analytic Rabi oscillation.
pk.PauliTable	Vectorised symplectic table of n-qubit Pauli operators.
pk.StabilizerState	Exact stabilizer-formalism state (CHP tableau) for Clifford circuits, scaling to thousands of qubits.

Circuit examples (new in v6.1.6)

import pktron as pk
import numpy as np

# 1) GPU statevector via cuStateVec (auto CPU fallback off-GPU)
qc = pk.QuantumCircuit(2); qc.h(0); qc.cx(0, 1)
res = pk.cuStateVec().run(qc, shots=1024)
print(res["counts"])           # ~ {'00': ~512, '11': ~512}
print(pk.is_gpu_available())   # True on a CUDA + cuQuantum runtime

# 2) Exact stabilizer simulation of a Clifford circuit
ghz = pk.QuantumCircuit(3); ghz.h(0); ghz.cx(0, 1); ghz.cx(1, 2)
st = pk.StabilizerState(ghz)
print(st.probabilities_dict())       # {'000': 0.5, '111': 0.5}
print(st.expectation_value("ZZI"))   # 1.0

# 3) Automatic backend selection (picks stabilizer for Clifford circuits)
print(pk.auto_select_method(ghz))    # 'stabilizer'
print(pk.AutoBackend().run(ghz, shots=2000)["counts"])

# 4) Transpiler gate fusion (fewer gates, identical statevector)
deep = pk.QuantumCircuit(2)
for _ in range(8): deep.h(0); deep.t(0); deep.h(1)
fused = pk.PassManager([pk.GateFusionPass()]).run(deep)
print(len(deep.gates), '->', len(fused.gates))   # e.g. 24 -> 2

# 5) Synthesise an arbitrary 2-qubit unitary into native gates
U, _ = np.linalg.qr(np.random.randn(4, 4) + 1j*np.random.randn(4, 4))
qc = pk.QuantumCircuit(2)
pk.UnitarySynthesis().apply(qc, U, [0, 1])        # qc now reproduces U

# 6) Pulse-level dynamics: a pi-pulse (Rabi) on one qubit
X = np.array([[0, 1], [1, 0]], complex); Omega = 2*np.pi
dyn = pk.DynamicsBackend(static_hamiltonian=np.zeros((2, 2), complex),
                         hamiltonian_operators=[X])
out = dyn.solve(np.array([1, 0], complex), [lambda t: 0.5*Omega], t_final=0.5)
print(np.round(out["probabilities"], 3))   # ~ [0, 1]  (|0> -> |1>)

---

What's new in v6.0.0

Class	What it does
pk.Pauli	Symplectic-representation Pauli class with full algebra: @ composition, ^ tensor product, commutes(), to_matrix(), adjoint(). Verified: XY = iZ, [X,X]=0, {X,Z}=0.
pk.E91Protocol	Ekert91 entanglement-based QKD with CHSH inequality test. Clean channel CHSH ≈ 2.77, with eavesdropper drops below 2 → intrusion detected.
pk.M3MeasurementMitigation	Matrix-free / subspace readout error mitigation. Solves only over observed bitstrings — scales to many qubits where direct inversion fails.
SparsePauliOp at top level	Was buried in pktron.quantum_info.operators, now pk.SparsePauliOp.
DMRGSolver under tensor_networks	Was in pktron.dmrg, now also pktron.tensor_networks.DMRGSolver.
MPS SVD bug fix	MPSSimulator._apply_2q_nn self._fast_svd → np.linalg.svd. Entangling circuits run correctly on MPS now.

---

Installation

pip install pktron

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

---

Quick-Start

Bell state

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}

Or use the top-level execute() helper

qc = pk.QuantumCircuit(2); qc.h(0); qc.cx(0, 1)
print(pk.execute(qc, shots=1024)["counts"])

Grover's Search (4 qubits, 2 marked states)

g = pk.GroverSearch(n_qubits=4, marked_states=[5, 10])
r = g.run()
print(f"Found: {r['found']}  probability: {r['success_prob']:.3f}")

VQE on H₂ — matches FCI exactly

H = pk.QuantumChemistry.h2_hamiltonian(distance=0.735)
r = pk.VQE(H).run(ansatz_depth=2, max_iter=200)
print(f"Ground energy: {r['energy']:.6f} Ha")
# Ground energy: -1.872798 Ha  (FCI = -1.872798 Ha)

Pauli algebra (v6.0.0)

import pktron as pk

p = pk.Pauli("XYZ")
print(p, p.num_qubits, p.to_matrix().shape)   # XYZ 3 (8, 8)

# Physics is correct
xy = pk.Pauli("X") @ pk.Pauli("Y")
print(xy)                                      # iZ

assert pk.Pauli("X").commutes(pk.Pauli("X"))      # True
assert pk.Pauli("X").anticommutes(pk.Pauli("Z"))  # True

E91 entanglement-based QKD (v6.0.0)

import pktron as pk

clean = pk.E91Protocol.run(n_pairs=2048, eavesdrop=False, visibility=0.98, seed=42)
print(f"Clean CHSH={clean['chsh_s']:.2f}  secure={clean['secure']}  qber={clean['qber']:.3f}")
# Clean CHSH=2.77  secure=True  qber=0.020   (Tsirelson bound = 2√2 ≈ 2.83)

eve = pk.E91Protocol.run(n_pairs=2048, eavesdrop=True, visibility=0.98, seed=42)
print(f"Eavesdrop CHSH={eve['chsh_s']:.2f}  detected={eve['eavesdropping_detected']}")
# Eavesdrop CHSH=1.39  detected=True

M3 measurement mitigation (v6.0.0)

import pktron as pk

noisy_counts = {"000": 8500, "111": 9000, "001": 850, "110": 850,
                "010": 350, "101": 350, "011": 50, "100": 50}

m3 = pk.M3MeasurementMitigation(n_qubits=3).calibrate(p1_given_0=0.03, p0_given_1=0.04)
mitigated = m3.mitigate(noisy_counts)
print(sorted(mitigated.items(), key=lambda x: -x[1])[:3])

Surface-code error scaling (sub-threshold)

for d in [3, 5, 7]:
    scd = pk.SurfaceCodeDistance(distance=d)
    r = scd.logical_error_rate(noise_rate=0.001)
    print(f"d={d}: P_L = {r['logical_x_rate']:.2e}")
# d=3: P_L = 3.00e-04
# d=5: P_L = 3.00e-05
# d=7: P_L = 3.00e-06

---

Complete Feature Reference

This is everything that ships in pip install pktron. All 150 classes, 26 functions, and 39 submodules are listed here so you know exactly what's available.

Core Simulators (13 backends)

Simulator	Description
StatevectorSimulator	Exact full-statevector (≤28 qubits)
UnitarySimulator	Returns the full unitary matrix
DensityMatrixSimulator	Mixed states + Kraus channels
MPSSimulator	Matrix Product State (20–100 qubits)
CliffordSimulator	Stabilizer tableau (millions of qubits)
ExtendedStabilizerSimulator	Clifford + T gates
SuperOpSimulator	Superoperator representation
PulseLevelSimulator	Time-domain Lindblad master equation
QuantumTrajectorySimulator	Monte Carlo wave-function trajectories
PEPSSimulator	Projected Entangled Pair States (2D)
MERASimulator	Multi-scale Entanglement Renormalization
TensorNetworkSimulator	General tensor network simulation
MultiGPUSimulator	Distributed GPU statevector

Specialty simulators (in submodules):

• MatchgateSimulator (pktron.matchgate_sim) — efficient matchgate / free-fermion circuits
• FermionicGaussianSimulator (pktron.fermionic_gaussian) — Gaussian-state fermionic simulator
• AdaptiveMPSSimulator (pktron.advanced) — entanglement-adaptive MPS

Circuit Construction

Core classes:

• QuantumCircuit — primary circuit object
• Gate — individual gate with name, qubits, params, matrix
• Parameter, ParameterVector — symbolic parameters

Single-qubit gates: H, X, Y, Z, S, T, SDG, TDG, SX, SXDG, I/ID, RX, RY, RZ, P/Phase, U3, U2, U1 Two-qubit gates: CX/CNOT, CY, CZ, SWAP, ISWAP, DCX, ECR, CRX, CRY, CRZ, RXX, RYY, RZZ, CP, CU, CH, CT Three-qubit gates: CCX/Toffoli, CSWAP/Fredkin

Top-level gate factories: RX(), RY(), RZ(), U3()

Circuit Operations:

• .compose(), .tensor(), .inverse(), .repeat(), .control(), .power()
• .assign_parameters(), .bind_parameters()
• .gate_count(), .analysis(), .depth(), .to_dag()
• .barrier(), .measure(), .save_statevector()
• .draw(mode='unicode'/'text'/'mpl', fold=80)

Control-flow instructions: IfInstruction, ForLoopInstruction, WhileLoopInstruction, SaveInstruction

Compilation & Transpilation

Pass manager (pktron.core):

• PassManager, TranspilerPass
• GateCancellationPass — cancels X•X → I, etc.
• TCountOptimizationPass — T•T → S, S•S → Z
• SABRERoutingPass, SABRERouter — routing for connectivity constraints
• LocalNoisePass — inject depolarizing noise per gate
• RelaxationNoisePass — T1/T2 relaxation noise

Compiler IR:

• QuantumIR (pktron.compiler.ir)

Noise-aware compilation:

• NoiseAwareCompiler (pktron.noise_aware_compile)

KAK / Euler decomposition (pktron.decompose):

• euler_zyz() — ZYZ Euler angles for any SU(2)
• decompose_1q_to_basis() — ZYZ, IBM (RZ+SX), U3
• kak_decomposition() — Cartan decomposition of SU(4)
• decompose_2q_to_cnot() — arbitrary 2-qubit → CNOT + 1q gates

Serialization

• save_circuit(), load_circuit() — QPY binary format
• circuit_to_qasm2(), circuit_from_qasm2() — OpenQASM 2.0
• circuit_to_qasm3() — OpenQASM 3.0
• circuit_to_dict(), circuit_from_dict() — JSON dict
• OpenQASM3 (pktron.advanced)
• QuilExporter — Rigetti Quil 2.x with DEFGATE
• IonQExporter — IonQ JSON with schema validation
• BraketExporter — Amazon Braket IR (OpenQASM + JAQCD)

Interoperability

• InteropConverter (pktron.interop) — unified converter class
• QiskitImporter — all Qiskit standard gates + to_matrix() fallback
• CirqImporter — Cirq Circuit with moment structure
• PennyLaneImporter — QNode / QuantumTape import

Quantum Primitives (Qiskit-compatible)

• Sampler, SamplerJob, SamplerResult
• Estimator, EstimatorJob, EstimatorResult
• Session-based batching

Quantum Algorithms (50+ classes)

Search & Optimization:

• GroverSearch — diagonal-matrix oracle, correct for any n
• AmplitudeAmplification — generalized Grover
• QuantumCounting — counts marked states via QPE
• QAOA / qaoa_max_cut() — variational combinatorial optimization
• QuantumAnnealing, QuantumAnnealing2 — quantum annealing

Factoring & Number Theory:

• Shor — QPE-based period finding + classical post-processing

Function Problems:

• DeutschJozsa — correct constant oracle (all_zero_prob = 1.0)
• SimonsAlgorithm — quantum circuit + GF(2) classical recovery

Phase & Transform:

• QuantumFourierTransform — QFT unitary and circuit
• QuantumPhaseEstimation — controlled-U chain + IQFT

Linear Algebra:

• HHLAlgorithm — Harrow–Hassidim–Lloyd linear systems

Walks & Dynamics:

• QuantumWalk, QuantumWalkSearch

Advanced algorithms (pktron.advanced_algorithms):

• QuantumMetropolis — quantum Metropolis sampling
• LCUFramework — linear combination of unitaries
• QuantumSDP — quantum semidefinite programming
• AdiabticQuantumOptimizer — adiabatic optimization
• QuantumPhaseKickback — phase-kickback primitives

New algorithms (pktron.new_algorithms):

• QuantumWalkSearch — quantum walk-based search
• VariationalQuantumEigensolver2 — extended VQE
• QuantumOptimalControl — GRAPE: L-BFGS-B with analytical gradient
• QuantumAnnealing2 — enhanced annealing
• QuantumNeuralArchitectureSearch — NAS for quantum circuits
• QuantumErrorLearning — process tomography + GST

Variational Algorithms (VQE family)

• VQE — hardware-efficient ansatz, parameter-shift BFGS
• VariationalQuantumEigensolver2 — extended VQE
• QAOA — QAOA with p layers

Chemistry-specific VQE (pktron.advanced):

• UCCSDSolver — UCCSD-VQE, reaches FCI on H₂
• ADAPTVQESolver — skew-Hermitian pool, multi-layer, monotone

Quantum Chemistry

• QuantumChemistry — hamiltonian builders, mappers, transformers
• QuantumChemistry.h2_hamiltonian() — exact STO-3G H₂
• Molecular library: H₂, N₂, CH₄, CO₂, NH₃, C₂H₄
• Mappers: ParityMapper, BravyiKitaev (Fenwick tree), Jordan–Wigner
• Transformers: ActiveSpaceTransformer, FreezeCoreTransformer, Z2Symmetries
• Initial states: HartreeFockInitialPoint, Molecule

Quantum Machine Learning

Core QML (pktron.core):

• QuantumNeuralNetwork — parametric QNN, analytic gradients
• QSVM — Quantum Support Vector Machine
• QuantumGAN — Quantum Generative Adversarial Network
• QuantumAutoencoder — circuit-based autoencoder
• QuantumCNN — Quantum Convolutional Neural Network
• QuantumBoltzmannMachine — QBM with FD gradient
• QuantumFederatedLearning — federated quantum learning
• QuantumReinforcementLearning — RL with quantum policy
• QuantumTransferLearning — transfer-learning circuits

Advanced QML (pktron.advanced_qml):

• BarrenPlateauFreeQNN — barren-plateau-resistant QNN
• QuantumKernelTrainer — quantum kernel learning
• QuantumMetaLearner — quantum meta-learning
• ShotFrugalOptimizer — shot-efficient variational optimizer

Barren plateau analysis (pktron.barren_plateau):

• BarrenPlateauAnalyzer — trainability diagnostics

Gradient methods (pktron.gradients):

• ParameterShiftGradient — exact parameter-shift rule, Hessian

Optimizers (pktron.advanced):

• JAXOptimizer — autodiff via JAX backend

Noise Models

Channels (pktron.noise_models):

• NoiseChannel — base class
• DepolarizingNoise, AmplitudeDamping, PhaseDamping
• CrosstalkNoiseModel, ThermalNoiseModel

In pktron.core:

• NoiseModel — composable noise model
• PauliError — weighted Pauli channel
• PauliLindbladError — Lindblad form Pauli noise

Noise application:

• LocalNoisePass — per-gate noise injection
• RelaxationNoisePass — T1/T2 relaxation

Error Correction (6 codes)

• Steane7QEC — [[7,1,3]] Steane code: encode, syndrome, correct
• SurfaceCode — arbitrary odd distance d, stabilizers, logical ops
• SurfaceCodeDistance — monotone logical error rate formula
• BaconShorCode — [[9,1,3]] Bacon–Shor code
• ColorCode — triangular 2D color code
• RepetitionCode — bit-flip and phase-flip codes
• HeavyHexCode — IBM heavy-hex layout
• FaultTolerantCircuit — syndrome extraction between logical gates

Decoders:

• BlossomVDecoder — pure-Python MWPM decoder
• PyMatchingDecoder — PyMatching wrapper (optional dependency)
• ThresholdEstimator — Monte Carlo threshold estimation
• DecoderComparison — greedy vs MWPM benchmark

Logical operations: logical_x(), logical_z(), logical_h(), logical_cnot()

Error Mitigation

Core mitigation (pktron.core):

• ZeroNoiseExtrapolation — Richardson extrapolation, poly, exp
• ProbabilisticErrorCancellation — quasi-probability
• ReadoutErrorMitigation — matrix inversion (full)
• CliffordDataRegression — CDR
• DynamicalDecoupling — XY4 and other sequences

Advanced mitigation (pktron.advanced_mitigation):

• SymmetryVerification — post-selection on conserved quantities
• ProbabilisticErrorAmplification — PEA
• PauliNoiseLearner — learn the noise model from data

Specialized mitigation:

• M3MeasurementMitigation (pktron.m3_mitigation) — NEW in v6.0.0, matrix-free / subspace
• VirtualDistillation (pktron.advanced) — virtual distillation purification

ZNE folding strategies: fold_global, fold_gates_from_left, fold_gates_at_random Extrapolators: RichardsonExtrapolation, ExponentialExtrapolation, PolyExpExtrapolation Twirling: PauliTwirlingPass, CliffordTwirlingPass

Quantum Benchmarking

• QuantumBenchmarking — unified: QV, RB, CLOPS, XEB, gate fidelity
• StandardRB — randomized benchmarking, EPC, decay fit
• InterleavedRB — per-gate EPC via interleaved Clifford
• MirrorRB — mirror circuits, polarization
• XEB — cross-entropy benchmarking, per-cycle fidelity
• CLOPS — circuit-layer operations per second
• StateTomography — MLE-projected density matrix reconstruction
• ProcessTomography — χ-matrix via Choi isomorphism
• GateTomography (GST) — linear + iterative MLE
• LayerFidelityEstimator — simultaneous RB
• LayerFidelityBenchmark

Pauli Framework

Top-level (v6.0.0):

• pk.Pauli — NEW, symplectic representation, full Pauli algebra
• pk.SparsePauliOp — sparse weighted sum: +, -, *, @, **, adjoint, simplify, chop

Module (pktron.pauli):

• Pauli — same as top-level, full arithmetic
• PauliTerm, PauliSum — sparse Pauli algebra
• pauli_basis(n), pauli_basis_labels(n) — all 4^n Paulis
• commutes(), commutator(), anti_commutator()
• qubit_wise_commuting_groups() — QWC partitioning
• general_commuting_groups() — full commutativity graph coloring
• PauliGrouper — measurement-reduction orchestrator with basis-rotation circuits

Sparse Hamiltonians (pktron.sparse):

• SparseHamiltonian — CSR-format sparse H
• ising_hamiltonian(), heisenberg_hamiltonian(), transverse_ising()
• from_dense() — matrix → sparse Pauli decomposition
• expectation_pauli_string() — O(dim•n) without full matrix

Pulse-Level Simulation

• Channels: DriveChannel, ControlChannel, MeasureChannel, AcquireChannel
• Pulse shapes: Waveform, Gaussian, GaussianSquare, Drag, Constant
• Instructions: Play, Delay, Acquire, ShiftPhase, SetFrequency
• Schedules: Schedule (<<, | operators), ScheduleBlock (4 alignment modes)
• Simulator: PulseLevelSimulator — Lindblad RK4 master equation
• Calibration: InstructionScheduleMap, attach_calibration, build_standard_inst_map
• Pulse gates: DRAGPulse (calibrated X gate), CrossResonancePulse

Quantum Cryptography

Core protocols:

• BB84Protocol — QKD with realistic QBER floor (0.5%), eavesdrop detection
• E91Protocol — NEW in v6.0.0, entanglement-based with CHSH security test
• PostQuantumCrypto — post-quantum cryptographic primitives

Advanced crypto (pktron.advanced_crypto):

• BlindQuantumComputing — blind quantum computing protocols
• QuantumDigitalSignature — quantum digital signatures
• QuantumMoney — quantum money schemes
• QuantumSecretSharing — quantum secret-sharing

QKD pipeline (pktron.qkd_pipeline):

• QKDPipeline — BB84, E91, B92, TF-QKD, MDI-QKD, DIQKD

Finance Module (pktron.finance)

• QuantumAmplitudeEstimation — QAE via Grover operator + QPE
• QuantumPortfolioOptimizer — Markowitz → Ising → QAOA
• QuantumOptionPricer — European/Asian options via QAE
• QuantumCreditRisk — VaR/ES via amplitude estimation
• QuantumMonteCarlo — QMC integration engine
• QuantumAnomalyDetection — quantum kernel variational classifier

Defense Module (pktron.defense)

• QuantumVRP — vehicle routing via QUBO → QAOA
• QuantumGameTheory — Nash equilibrium via variational circuits
• QuantumMissionScheduler — RCPSP scheduling via QAOA
• QuantumSwarmOptimizer — multi-agent QAOA coordination
• QuantumTargetDetection — ZZ-feature map + variational classifier
• QuantumCryptanalysis — enhanced period finding + SVP + Grover key search

HPC Subsystem

C kernel (pktron.kernels):

• sv_kernels.c — AVX-512/AVX2/SSE/OpenMP statevector kernels
• apply_1q_gate, apply_h/x/y/z/s/t, apply_rz/ry
• apply_2q_gate, apply_cx/cz/swap
• fuse_1q_chain — multi-gate fusion
• compute_probs, sample_measurements
• expectation_diag, expectation_dense, expectation_csr (sparse)
• normalize_sv
• KernelSet — Python wrapper with NumPy fallback

Top-level C-backend functions (pktron.c_backend):

• apply_1q_gate_c(), apply_2q_gate_c()
• compute_probs_c(), sample_c()
• expectation_diag_c(), expectation_dense_c()
• c_backend_info() — returns AVX/OpenMP/thread info

Scheduler (pktron.scheduler):

• build_schedule(), Schedule, OpNode
• Gate normalization, 1-qubit fusion pass, Clifford detection

Runtime (pktron.runtime):

• StatevectorRuntime — routes through kernel/scheduler + MPS auto-routing
• GPU → CuPy path, CPU → C kernel, Clifford → tableau
• TaskGraphScheduler, AsyncExecutor

Sparse ops (pktron.sparse):

• PauliTerm, SparseHamiltonian
• ising_hamiltonian(), heisenberg_hamiltonian(), from_dense()
• expectation_pauli_string() — O(dim•n) per term

Circuit cache (pktron.cache):

• CircuitCache — 2-level LRU (memory) + shelve (disk)
• SHA-256 circuit key, thread-safe, hit-rate tracking

GPU backend (pktron.gpu):

• GPUBackend — CuPy, CUDA RawKernels, memory pool
• Kernels: apply_h_gpu, apply_1q_gpu, apply_cx_gpu
• Falls back to CuPy tensordot then CPU

Multi-GPU (pktron.multi_gpu_engine):

• MultiGPUSimulator — distributed GPU statevector
• GPUScheduler — device placement and load balancing

Distributed (pktron.distributed):

• DistributedRuntime — MPI rank partitioning via mpi4py
• Local-qubit gates (no communication), global-qubit gates (MPI_Sendrecv)

Benchmarks (pktron.benchmarks):

• bench_gate_scaling, bench_gate_types, bench_fusion_speedup
• bench_expectation, bench_sampling, bench_full_circuit
• bench_openmp_scaling, bench_correctness
• run_all(quick=True/False)

Hardware & Backend Infrastructure

Hardware backend (pktron.core):

• HardwareBackend — physical/mock device with noise
• SABRERouter — SABRE routing for connectivity constraints

Modular backend registry (pktron.modular_backends):

• BackendRegistry, BackendPlugin, BackendCapabilities
• BackendLifecycleManager
• find_best_backend() — auto-selects by circuit properties

Calibration & drift:

• CalibrationData, QubitCalibration (pktron.hardware_calibration)
• DriftEngine, CalibrationDriftSimulator (pktron.drift_simulator)
• GateScheduler, GateSequence, TimingInfo (pktron.gate_scheduler)

Hardware reporting (pktron.hardware_report):

• HardwareExecutionReport

Dynamic circuits (pktron.dynamic_circuits):

• DynamicCircuit — circuits with classical feedback
• MidCircuitMeasurement
• ConditionalGate

Virtual devices (pktron.virtual_devices):

• VirtualDevice — mock backend with realistic topology and noise

Tensor Networks (pktron.tensor_networks)

• MPSNetwork — MPS state with per-site tensors
• DMRGSolver — DMRG ground state for Ising/Heisenberg (also at pktron.dmrg)
• AdaptiveMPSSimulator — entanglement-adaptive MPS

QSVT (Quantum Singular Value Transformation, pktron.qsvt)

• QSVT — QSP angle finder (Adam gradient descent), QSVT circuits
• QSPAngleFinder — Chebyshev–Gauss nodes optimization
• QSPCircuit — assembles full U_φ circuit
• LinearCombinationBlockEncoding, SparseAccessBlockEncoding
• Methods: hamiltonian_simulation, ground_state_projector, apply_function, linear_system_solve

Circuit Visualization (pktron.circuit_drawing)

• CircuitDrawer — text (ASCII), unicode box-drawing, matplotlib
• Modes: 'text', 'unicode', 'mpl'
• QuantumCircuit.draw() — .draw(mode='unicode', fold=80)
• QuantumCircuit.__repr__() — auto-draws in notebooks

Circuit Debugger (pktron.circuit_debugger)

• QuantumCircuitDebugger — step-through circuit execution with intermediate states

Infrastructure & Tooling

Config (pktron.config):

• PKTronConfig, get_config(), set_config(), reset_config()

Validation (pktron.validation):

• QuantumStateValidator, validate_input()
• PhysicsValidator — checks norm, Hermiticity, PSD, Bloch vector

Profiling (pktron.profiling):

• PerformanceMonitor, get_profiler()

Top-level helpers:

• pk.execute(qc, shots=...) — one-liner circuit execution
• pk.backend_info() — returns version + compiled-backend status

Benchmark registry:

• BenchmarkRegistry — classification tags (exact/approximate/heuristic/mock)
• run_seeded(42), report()

---

Complete Submodule Index

Every importable subpackage that ships with PkTron:

pktron                          # top level (~190 public symbols re-exported here)
pktron.core                     # 89 classes/functions — simulators, algorithms, gates
pktron.advanced                 # UCCSDSolver, ADAPTVQESolver, AdaptiveMPSSimulator,
                                #   JAXOptimizer, OpenQASM3, SurfaceCodeDistance,
                                #   VirtualDistillation
pktron.advanced_algorithms      # QuantumMetropolis, LCUFramework, QuantumSDP,
                                #   AdiabticQuantumOptimizer, QuantumPhaseKickback
pktron.advanced_crypto          # BlindQuantumComputing, QuantumDigitalSignature,
                                #   QuantumMoney, QuantumSecretSharing
pktron.advanced_mitigation      # PauliNoiseLearner, ProbabilisticErrorAmplification,
                                #   SymmetryVerification
pktron.advanced_qml             # BarrenPlateauFreeQNN, QuantumKernelTrainer,
                                #   QuantumMetaLearner, ShotFrugalOptimizer
pktron.barren_plateau           # BarrenPlateauAnalyzer
pktron.benchmarks               # HPC benchmark suite
pktron.c_backend                # C-extension Python bindings
pktron.cache                    # CircuitCache (LRU + shelve)
pktron.circuit_debugger         # QuantumCircuitDebugger
pktron.circuit_drawing          # CircuitDrawer
pktron.compiler                 # QuantumIR (compiler IR)
pktron.config                   # PKTronConfig
pktron.decompose                # KAK / Euler decomposition
pktron.defense                  # 6 defense classes
pktron.distributed              # MPI distributed runtime
pktron.dmrg                     # DMRGSolver
pktron.drift_simulator          # CalibrationDriftSimulator, DriftEngine
pktron.dynamic_circuits         # DynamicCircuit, MidCircuitMeasurement
pktron.e91_protocol             # E91Protocol  (NEW in v6.0.0)
pktron.fermionic_gaussian       # FermionicGaussianSimulator
pktron.finance                  # 6 finance classes
pktron.gate_scheduler           # GateScheduler, GateSequence
pktron.gpu                      # GPUBackend (CuPy)
pktron.gradients                # ParameterShiftGradient
pktron.hardware_calibration     # CalibrationData, QubitCalibration
pktron.hardware_report          # HardwareExecutionReport
pktron.interop                  # InteropConverter (Qiskit / Cirq / PennyLane)
pktron.kernels                  # C statevector kernels (.so packaged in wheel)
pktron.m3_mitigation            # M3MeasurementMitigation  (NEW in v6.0.0)
pktron.matchgate_sim            # MatchgateSimulator
pktron.modular_backends         # BackendRegistry, BackendPlugin
pktron.multi_gpu_engine         # MultiGPUSimulator, GPUScheduler
pktron.new_algorithms           # 6 new algorithms (GRAPE, NAS, QErrorLearning, …)
pktron.noise_aware_compile      # NoiseAwareCompiler
pktron.noise_models             # 6 noise channels
pktron.pauli                    # Pauli (NEW), PauliTerm, PauliSum
pktron.profiling                # PerformanceMonitor
pktron.qkd_pipeline             # QKDPipeline
pktron.qsvt                     # QSVT
pktron.quantum_info             # SparsePauliOp (also at top level in v6.0.0)
pktron.runtime                  # StatevectorRuntime
pktron.scheduler                # Op-graph scheduler
pktron.sparse                   # SparseHamiltonian, Ising/Heisenberg builders
pktron.tensor_networks          # MPSNetwork, DMRGSolver (NEW re-export), AdaptiveMPSSimulator
pktron.validation               # QuantumStateValidator, PhysicsValidator
pktron.virtual_devices          # VirtualDevice

---

Why PkTron Ranks Top in Asia and Globally Top 5

Feature	PkTron v6.0.0	Typical alternatives
Simulator backends	13 (incl. matchgate, fermionic-gaussian, pulse-level)	3–5
Native gate set	23+ gates	10–15
Quantum algorithms	50+	10–20
Variational/Chemistry VQE family	9 (VQE, UCCSD, ADAPT, kUpCCGSD, PUCCD, SUCCD, qEOM, SSVQE, EvolvedOp)	1–2
QML algorithms	13 (incl. BarrenPlateauFreeQNN, MetaLearner, KernelTrainer)	2–4
QEC codes	6 (Steane, Surface, Bacon-Shor, Color, Repetition, Heavy-Hex)	1–2
Error mitigation methods	9+ (ZNE, PEC, CDR, M3 NEW, DD, twirling, PEA, VD, SymVer)	1–2
QKD protocols	6 (BB84, E91 NEW, B92, TF, MDI, DI)	1
Finance industry module	✅ 6 classes	✗
Defense industry module	✅ 6 classes	✗
HPC C kernel (AVX-512/OMP)	✅	✗
GPU backend (CuPy)	✅	Optional/paid
MPI distributed runtime	✅	Rare
Tensor networks (MPS/PEPS/MERA/DMRG)	✅	Limited
Interop targets	5 (Qiskit, Cirq, PennyLane, QASM3, Quil)	1–2
Open source	✅ MIT	Often proprietary
PyPI downloads	10K+	Varies

---

License

MIT License — Copyright © 2024–2026 CETQAC