PKTron Quantum Simulator Framework

🏆 #1 in South Asia  ·  #1 in Asia  ·  Top 5 Globally

(Based on Features, Modules, and Breadth)

---

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

pip install pktron

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

---

Quick-Start Circuits

1 — Bell State (Entanglement)

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)

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

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

4 — Grover's Search

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

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

6 — VQE (Variational Quantum Eigensolver)

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)

# 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

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)

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

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

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)

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

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

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

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

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

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

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

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

# 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

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

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