Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Encoding metric fallacy: Entanglement capability and Fourier decomposition provide minimal insight into actual encoding performance. Use effective rank of feature maps instead — it correlates with QML model performance and can serve as a threshold criterion to prune poor encodings before expensive training (arXiv:2605.18540)
⚠️ Measurement-induced logit contraction (arXiv: 2606.22551): Pauli measurement outputs are bounded to [-1,1]. When used with cross-entropy loss + softmax for multi-class classification, the loss operates in weak sensitivity regime → gradients suppressed → training instability. Fix: Quantum Measurement Temperature (QMT) — add a learnable scaling parameter τ that rescales logits before loss: rescaled = quantum_logits / τ. Architecture-agnostic, validated on protein classification and Fashion MNIST. See references/qmt-measurement-temperature.md.
⚠️ Reference-frame generalization impossibility (arXiv: 2606.22331): QML CANNOT generalize to unseen quantum directions without a reference frame. If training states span subspace S ⊂ H, all states orthogonal to S receive the SAME prediction — even when mutually orthogonal. Learning generic unstructured concepts requires exponentially many independently oriented training directions. Feature maps, measurement bases, Hamiltonians, symmetry priors are MANDATORY operational resources, not optional. See references/qml-generalization-impossibility.md.
Implementation Checklist
Choose encoding matching data structure
Ansatz depth balances expressivity and trainability
Use parameter-shift rule for gradient computation
Validate with noise simulation before hardware execution
Pattern 2: QAOA Parameter Scheduling
QAOA solves combinatorial optimization via alternating problem/ mixer Hamiltonians.
Key Insight
Instead of variational optimization, use spectral gap informed parameter schedules (de-variationalization):
Linear Ramp QAOA: parameters follow adiabatic evolution schedule
Spectral gap determines optimal transition rate between problem and mixer terms
Quantum cost function design enables distributed convergence
Q-ANCHOR (arXiv:2605.30075): Quantum Federated Learning with ZNE-guided server anchoring + stateful client correction to address double-drift (client drift from non-IID data + hardware bias from noisy quantum gradients)
When to Use
Large linear systems, distributed optimization
Multi-device quantum networks with classical coordination
Pattern 5: Geometric/Symmetry-Aware QML
Embed symmetries into quantum circuits via equivariant gates.
Approach
Identify symmetry group (finite or compact Lie group)
Construct equivariant quantum circuit ansatz
Reduces parameter count and improves generalization
Particularly effective for PDE solving with geometric structure (GQPINN)
Pattern 6: Hybrid Tensor Networks with Trainable Post-Selection
Tensor networks as ML models can be hybridized with quantum execution.
Core Idea
Post-selection is the key property interpolating between classical and quantum tensor networks. Introduce a trainable hyperparameter controlling the post-selection budget allocation:
0 post-selection → pure classical tensor network
Full post-selection → pure quantum tensor network
Partial → hybrid (practical NISQ regime)
Design Workflow
Start with classical tensor network backbone (MPS, PEPS, TTN)
Select edges for quantum replacement
Define post-selection budget
Jointly optimize model parameters + post-selection allocation
Let the model learn where quantum matters most
Key Insight
Post-selection budget complements bond dimension as a second capacity control axis. Trainable allocation beats fixed allocation on NISQ devices.
Pattern 7: GST-Based Quantum Circuit Synthesis
Generate hardware-native quantum circuits directly from Gate Set Tomography data.
Architecture Pipeline
Raw GST data → Tokenization → Curriculum Learning → Set-ViT → Concept Space → Diffusion Model → Circuit Synthesis
Key Advantages
End-to-end: Bypasses traditional GST+unitary-decomposition two-step pipeline
Context-aware: Set-ViT captures shared physical noise (crosstalk, drift) across circuits
Generative: Diffusion model samples circuits conditioned on target measurement distribution
Common pitfalls (data encoding bottleneck, barren plateaus, class imbalance, reproducibility)
Pattern 9: QUACOD — Coordinate Descent for NISQ Optimization
Decompose large-scale optimization problems into quantum-solvable subproblems via classical coordinate descent, enabling NISQ devices to handle problems far exceeding their qubit count.
Core Algorithm
Formulate as QUBO/Ising: Express objective as min x^T Q x + c^T x with constraints
Block partitioning: Divide n-bit variables into blocks of size k ≤ available qubits
Feature selection: L0-regularized regression with sparse variable selection
Implementation Template
def quacod_solve(Q, c, n, k_qubits, max_iter=100):
x = np.random.randint(0, 2, n)
for _ in range(max_iter):
block = select_block(x, Q, k_qubits) # greedy/random/graph
sub_Q = Q[np.ix_(block, block)]
sub_c = c[block] + 2 * Q[np.ix_(block, ~block)] @ x[~block]
x[block] = quantum_optimize(sub_Q, sub_c) # VQE/QAOA on subproblem
if converged(x): break
return x
Critical Pitfall
Block size ≠ qubit count: k should account for ancilla qubits needed by the ansatz. If you need 2 ancillas per logical qubit, set k = available_qubits / 2.
Pattern 10: Quantum-Inspired Dequantization
Classical polynomial-time algorithms that match purported quantum advantages, using the right mathematical tools.
Core Technique: Ridgelet Transform Sampling
For neural network lottery ticket (sparse subnetwork) selection:
Compute ridgelet transform of output weights → optimized probability distribution
Sample hidden nodes from this distribution in O(poly(D)) time
Quantum algorithm relies on state preparation + sampling from structured distribution
The distribution can be classically approximated via Monte Carlo or transform methods
Claims of exponential quantum speedup on classical ML tasks
Design Implication
Before investing in quantum hardware for ML tasks, verify the quantum speedup is not eliminable via classical polynomial-time approximation. Many "quantum ML advantages" are dequantizable.
Pattern 11: Quantum End-to-End Learning for Contextual Combinatorial Optimization
QEL (Lee & Kwon, arXiv:2605.20222) — the first quantum end-to-end learning framework for contextual combinatorial optimization (CCO).
Encodes contextual features directly into the quantum circuit via repeated data re-uploading layers
Analogous to state preparation in QAOA, but jointly captures relations among contexts, uncertain coefficients, and optimal solutions
Contextual encoder integrates seamlessly within the quantum policy
Advantages Over Classical Methods
Fewer parameters than classical benchmarks
No NP-hard solver calls — direct task-loss training despite discreteness and nonconvexity
Stationarity guarantee — gradient-based training converges despite nonconvexity
Exploits optimization-aware structure grounded in quantum physical principles
When to Use
Resource allocation under uncertainty with contextual features
Routing with time-varying demands
Portfolio optimization with market context
Any CCO problem where context-to-solution mapping is complex
Pattern 12: Bowtie VarQTE — Resource-Efficient Quantum State Preparation
Bowtie VarQTE (Drudis et al., arXiv:2605.20331) — hybrid classical-quantum variational time evolution using causal light-cone optimization.
Core Mechanism
For local Hamiltonians, the causal light-cone of an operator determines which qubits influence the measurement. Terms within the light-cone can be simulated classically; only genuinely quantum terms require quantum evaluation.
Algorithm
Compute light-cones for each gradient and QGT term
Classical simulation for causally relevant subcircuits
Quantum evaluation only for non-causal terms
Exact parameter updates via McLachlan's variational principle (A θ̇ = C)
NISQ-era state preparation where qubit budget is tight
Pattern 13: QUBO-Encoded RL Policy Search for Process Synthesis
Quantum-enhanced reinforcement learning for sequential decision problems with large discrete action spaces (arXiv: 2605.21213).
Core Idea
Encode RL policy decisions as binary variables and map policy optimization to QUBO, solved by quantum annealer or quantum-inspired solver.
Workflow
Process Problem → RL State/Action Design → QUBO Formulation →
Quantum Annealer Solver → Decode Solution → Validate Process Design
QUBO Formulation
min x^T Q x + c^T x where x ∈ {0,1}^n, Q encodes process constraints + economic objectives + safety bounds + RL reward
Key Advantages
Exponential reduction in search space exploration
Better global optima vs classical RL alone
Handles combinatorial complexity of process flowsheet design
When to Use
Chemical process design and optimization
Plant flowsheet synthesis
Industrial process optimization with large discrete decision spaces
Any sequential decision problem with combinatorial action space
Relationship to QUACOD (Pattern 9)
This paper encodes RL policy directly as QUBO for quantum annealing; QUACOD decomposes large QUBOs into quantum-solvable subproblems. For problems exceeding qubit count, combine both approaches.
Activation
quantum process synthesis, QUBO RL, quantum annealing optimization
quantum reinforcement learning, chemical process optimization
At current NISQ error rates (p ≥ 10⁻³), shallow angle-based encodings consistently outperform amplitude encoding despite the latter's exponential qubit advantage. This is the single most actionable finding.
Five-Regime Decision Framework
Map (D, n, p, τ) → encoding:
Low-D, High-p → Basis encoding
Medium-D, Medium-p → Angle/dense-angle encoding
High-D, Low-p (< 10⁻³) → Amplitude encoding
Complex features, Any-p → Data re-uploading
Hardware-aware → IQP when connectivity permits
Neural Network State Preparation (arXiv:2605.31006)
Alternative to variational encoding: train classical NN to map input data → quantum circuit parameters directly.
0.992 fidelity on unseen MNIST/Fashion-MNIST images
5000x runtime reduction per data instance
All optimization performed once during training phase
When to use: When per-instance state preparation bottleneck dominates QML pipeline
⚠️ Updated Pitfalls
Amplitude encoding's exponential advantage is nullified by decoherence at current NISQ error rates — default to angle-based unless p < 10⁻³
Fixed embedding ansatz selection without data geometry analysis leads to suboptimal performance
Ignoring the cost-expressivity-robustness triad results in untrainable circuits
Wasserstein distance in input space provides a priori diagnostic for encoding optimization saturation
Pattern 16: Forward Gradient Estimation for PQC Training (QUIVER)
Training parameterised quantum circuits is bottlenecked by gradient estimation cost. The parameter-shift rule scales O(P) with parameter count P, dominating shot budgets at scale.
Forward gradient estimators (arXiv:2606.09734) use forward-mode automatic differentiation to yield unbiased gradient estimates by averaging random directional derivatives — with no ancilla qubits or controlled-gate overhead.
Unified Framework
The estimator interpolates between established methods:
K=1, single random direction → SPSA (Simultaneous Perturbation)
K=P, canonical basis directions → random coordinate descent
K=P², full basis coverage → parameter-shift rule exactly
Pattern 17: Scalable On-Hardware QNN Training via Butterfly Circuits (2026-06-11)
Training QNNs on real quantum hardware is bottlenecked by gradient estimation: standard parameter-shift requires O(n²) circuit evaluations with trainable parameters.
Butterfly Circuit Architecture
Structured, subspace-preserving ansatz with O(n log n) parameters
Logarithmic circuit depth with commuting structure within each layer
Enables parallel gradient extraction within layers
Layer-Wise Training Strategy
Confine on-hardware optimization to one small layer at a time
Freeze trained layers before adding next layer
Add optional fine-tuning phase after full network assembled
Parallelized Parameter-Shift Rule
Exploit commuting structure within each Butterfly layer
Extract all gradients in constant number of circuit executions per layer
Reduces evaluations from O(n²) to O(log n) per optimization step
Validation on Real Hardware
IonQ Forte Enterprise trapped-ion hardware at 16 qubits (training)
Tensor-network simulation at 32 qubits
32-qubit inference executed directly on hardware
MIMIC-III EHR benchmark: matches/exceeds classical neural baselines
When to Use
QNN training on NISQ hardware with 16+ qubits
Clinical/medical data with optimization instability sensitivity
Any scenario where standard parameter-shift gradient estimation is the bottleneck
Layer-wise training may get stuck in local optima — add fine-tuning phase
Hardware noise still affects results — combine with error mitigation techniques
Relationship to Pattern 16 (Forward Gradient / QUIVER)
Pattern 17 reduces the number of circuit evaluations architecturally (O(n²) → O(log n)); Pattern 16 reduces the measurement cost per evaluation. They are complementary: use Butterfly circuits to reduce circuit count AND QUIVER to optimize shot allocation within each circuit.
Pattern 18: Non-Unitary QML via Trainable Quantum Channels (2026-06-23)
Traditional QML is constrained to unitary dynamics. This methodology (arXiv:2606.15808, Wen et al.) reformulates quantum channels as trainable computational primitives rather than detrimental noise.
Core Framework
ρ_out = Σ_k K_k(θ) U(φ) ρ_in U†(φ) K_k†(θ)
where K_k(θ) are trainable Kraus operators and U(φ) are standard unitary variational gates.
Three Key Innovations
Structured superposition: Channel-enhanced outputs form superpositions of multiple functional components, each with effective observables whose spectra adaptively modulate during training
Spectral modulation: Unlike unitary transformations (spectral invariance), channel parameters enable spectral changes — the eigenvalues of effective observables change as channel parameters are optimized
Enriched optimization geometry: Ensemble-averaged gradients across Kraus branches + additional optimization directions from non-unitary Kraus parameters
Implementation
Use trainable amplitude-damping or phase-damping channels as non-unitary layers
CPTP constraint enforcement: Stinespring dilation, projection after gradient steps, or penalty terms
Pattern 19: Anyonic Quantum Kernels via Fractional Exchange Statistics (2026-06-23)
Methodology from arXiv:2606.16090 (Zhang et al.) that unifies bosonic, fermionic, and anyonic exchange statistics within a single quantum kernel learning paradigm. Fractional exchange phases (θ ∈ (0, π)) access feature-space directions inaccessible to purely symmetric or antisymmetric limits.
Kernel geometry level: Anyonic Gram matrices show greater separation from distinguishable-particle baseline and reduced label-dependent model complexity
Learning performance level: Anyonic kernels consistently outperform bosonic/fermionic counterparts with stronger target alignment and more favorable class geometry
Network latency: Entanglement swapping adds latency/error to remote classification.
When to Use
Quantum-secured ML as network service, privacy-preserving delegated computation, NISQ proof-of-principle experiments
Pattern 21: Health-Aware HPO for Neural-Network Quantum States (2026-06-30)
Neural-network quantum states (NQS) variational accuracy depends sensitively on architecture-level hyperparameters and optimization schedules. Standard HPO (select lowest-energy run) is unreliable because destructive optimization events can mask good architectures.
NQS-Agent (arXiv:2606.30464, Wang et al.) introduces health-aware HPO that goes beyond final energy.
Core Pipeline
while not converged:
energy = compute_energy(params)
monitor(energy_trajectory)
if detect_instability(trajectory):
checkpoint = rollback_to_stable()
modify_lr_schedule(checkpoint)
resume_optimization(checkpoint, new_lr)
if detect_divergence(trajectory):
abort_candidate()
record("unstable")
Four-Phase Methodology
Energy Trajectory Monitoring: Continuously track energy curves, derivatives, variance
The stability and recovery history of an optimization trajectory should be considered when assessing an NQS result. Health-aware HPO provides a reproducible tuning protocol that goes beyond selecting a single lowest-energy calculation.
When to Use
NQS architecture search (residual CNN vs aCNN, wide-vs-deep)
Quantum many-body model tuning (Heisenberg, J1-J2, frustrated systems)
Any variational quantum calculation where gradient instability masks genuine convergence
Pitfalls
Single-run selection trap: Lowest-energy run may be a lucky convergence, not genuine. Always use multiple runs per configuration.
Checkpoint granularity: Too-frequent checkpoints waste memory; too-sparse lose too much progress. Checkpoint every 10-50 steps for NQS.
Instability threshold calibration: Energy derivative threshold for "instability" is physics-model-dependent. Calibrate on a known-good configuration first.
Parameter count matching: When comparing architectures, ensure fair comparison by matching parameter counts (wide-and-shallow vs deep-and-narrow).
Pattern 14: Quantum Simulation vs Sample-Based Learning Comparison
Empirical framework comparing two classical approaches to reproducing Born-rule statistics for quantum systems (arXiv:2605.28986).
Core Insight
Simulability ≠ Learnability: Systems that are hard to simulate from classical descriptions may still be efficiently learnable from measurement samples, and vice versa.
Complexity Classes
Class
Simulation
Learning
Example
Easy-Easy
Efficient
Efficient
Clifford circuits
Hard-Easy
Intractable
Efficient
Some random circuits
Easy-Hard
Efficient
Intractable
Structured systems
Hard-Hard
Intractable
Intractable
Generic quantum systems
When to Use This Framework
Verifying quantum advantage claims (simulation hardness alone is insufficient)
Choosing between simulation-based training vs sample-based training for quantum ML
Characterizing unknown quantum systems
Methodology
Define system class and complexity parameters (circuit depth, qubit count, noise)
Run classical simulation (exact or approximate) — record time/memory scaling
Run sample-based learning from measurement data — record sample complexity
For some random circuit ensembles, learning from O(poly(n)) samples succeeds where classical simulation requires exponential resources. This means quantum advantage claims based solely on simulation hardness need additional evidence.
