q-iPrune: One-Shot Pruning for QNNs

• The paper introduces q-iPrune, a one-shot, structured pruning algorithm that leverages q-deformed Lie groups and quantum geometric redundancy metrics to streamline quantum circuits.
• It employs a noise-calibrated deformation parameter and task-conditioned q-overlap distance to identify and remove algebraically consistent redundant gates with explicit error guarantees.
• Empirical evaluations on classification and VQE tasks demonstrate up to 60% gate reduction with minimal performance loss, ensuring robust optimization under NISQ conditions.

q-iPrune is a one-shot, structured pruning framework for quantum neural networks (QNNs) that leverages $q$-deformed Lie group representations and a task-conditioned quantum geometric redundancy metric. Designed for the noisy intermediate-scale quantum (NISQ) regime, q-iPrune rigorously formulates and eliminates gate-level redundancy by exploiting both the algebraic structure of $q$-groups and the operational similarities of gates on task-relevant state ensembles. It provides explicit, task-conditioned error guarantees, polynomial computational complexity, and integrates a noise-adaptive deformation parameter, distinguishing it from heuristic or gradient-based alternatives (Shao et al., 30 Dec 2025).

1. Algebraic Structure: $q$-Deformation and Hardware Adaptation

q-iPrune replaces the canonical $\mathrm{SU}(2)$ Lie group with its Drinfeld–Jimbo $q$-deformation, denoted $\mathrm{SU}_q(2)$. The deformation is controlled by a continuous parameter $\lambda \in [0,1]$, smoothly interpolating between the fully commutative limit ($\lambda \to 0$) and the conventional non-commutative $\mathrm{SU}(2)$ algebra ($\lambda=1$). The core components are:

• Deformation Function: $q(\lambda) := \exp[\beta (1-\lambda)]$ with $\beta>0$; as $\lambda \to 1$, $q \to 1$ and standard $\mathrm{SU}(2)$ is recovered.
• $q$-Lie Algebra: Generators $T_+, T_-, T_3$ satisfy $[T_+,T_-] = [2\,T_3]_q$, $[T_3, T_+] = T_+$, $[T_3,T_-] = -T_-$, with $[x]_q := (q^x - q^{-x})/(q - q^{-1})$.
• Noise-Adaptive Scaling: Scaled generators $T'_k := \lambda T_k$ yield commutators $[T'_i, T'_j] = \lambda^2 [T_i, T_j]$, capturing the decoherence-driven commutative contraction as $\lambda \to 0$.
• Gate Parametrization: Gate operators are constructed as $$U_q(\theta, \lambda) := \exp_q(i \sum_{k\in\{+,-,3\}}\theta_k T'_k)$$, using the $q$-exponential map.

Two-qubit gates (e.g., CNOT) are $q$-deformed via the Hopf coproduct, resulting in unitary $q$-generalizations such as $\mathrm{CNOT}_q(\lambda)$. Hardware noise is modeled through $\lambda$, allowing the algebra to adapt to physical device imperfections.

2. Redundancy Detection via $q$-Subgroups

Redundancy identification in q-iPrune is restricted to "algebraically consistent" $q$-subgroups. Given the full gate multiset $G = \{U_1, ..., U_N\}$, q-iPrune partitions $G$ into disjoint subsets ($G_r$, $r=1,\ldots,R$) where each $G_r$ is closed under (approximate) composition and inversion within $\mathrm{SU}_q(2)$ or $\mathrm{SU}_q(4)$ as appropriate. Within each subgroup, a single representative gate $U_\mathrm{ref}$ is chosen (commonly the medoid under the redundancy metric). All comparisons and redundancy assessments are confined to the corresponding subgroup, ensuring that any gate replacement preserves the local group-theoretic structure of the quantum circuit.

3. Task-Conditioned $q$-Overlap Distance

The operational similarity of gates is quantified using the task-conditioned $q$-overlap distance, defined on a finite ensemble $\mathcal{D}=\{\psi_1,\ldots, \psi_M\}$ (e.g., data encodings or VQE intermediates). The $q$-inner product is introduced: $$\langle \phi | \psi \rangle_q := \langle \phi | G_q | \psi \rangle$$ with $G_q \succ 0$ and $m_q I \preceq G_q \preceq M_q I$. This induces the norm $\| \psi \|_q^2 = \langle \psi | \psi \rangle_q$.

The task-conditioned $q$-overlap distance for compiled unitaries $U,V$ is

$$d_q(U, V) := \frac{1}{M} \sum_{k=1}^M \arccos \left( \frac{|\langle \psi_k | U^\dagger V | \psi_k \rangle_q|}{\|\psi_k\|_q^2} \right).$$

This quantity measures the average $q$-weighted angular deviation of $U$ and $V$ on the ensemble. A gate $U$ is classified as $\epsilon$-redundant with respect to $U_\mathrm{ref}$ if $d_q(U_\mathrm{ref}, U) \leq \epsilon$. This redundancy implies a guaranteed bound on expectation shifts of any observable $O$: $$| \mathrm{Tr}[O\, (U \psi \psi^\dagger U^\dagger) - O\, (V \psi \psi^\dagger V^\dagger)] | \leq \|O\|_{\mathrm{op}}\, \frac{2}{M_q} \sin \epsilon.$$

4. One-Shot Structured Pruning Algorithm

q-iPrune performs a single traversal of each $q$-subgroup, comparing all members to the designated reference gate. Gates within the $\epsilon_q$-redundancy threshold are removed; those exceeding it are retained. The algorithm is as follows:

• Compute the redundancy threshold: $\epsilon_q = \arcsin(\delta M_q / 2)$ for a given task deviation $\delta$.
• Initialize the set of kept gates $G_{\mathrm{keep}}$ as empty.
• For each $q$-subgroup $G_r$:
  • Select $U_\mathrm{ref}$ (the medoid under $d_q$).
  • Add $U_\mathrm{ref}$ to $G_{\mathrm{keep}}$.
  • For each $U \in G_r \setminus \{U_\mathrm{ref}\}$:
  • Compute $d_q(U_\mathrm{ref}, U)$.
  • Keep $U$ if $d_q(U_\mathrm{ref}, U) > \epsilon_q$; otherwise, discard.
• Return $G_{\mathrm{keep}}$.

There are no iterative retraining or gradient-based updates; each gate is processed once. The pruning is thus “one-shot” and structured, reflecting only algebraically and operationally justified redundancy.

5. Rigorous Theoretical Guarantees

Three main guarantees are established for q-iPrune:

1. Completeness of Redundancy Pruning: Only gates meeting the $\epsilon_q$-redundancy criterion are removed. Gates with $d_q (U_\mathrm{ref}, U) > \epsilon_q$ are always kept (Theorem 4.1).
2. Circuit-Level Functional Bound: Replacing $L$ gates by reference representatives, the trace distance between the original and pruned circuit outputs is bounded as

$$\|\rho_\psi - \rho'_\psi\|_1 \leq 2L \sqrt{1 - \frac{\cos^2 \epsilon_q}{M_q^2}} \leq \frac{2L}{M_q} \sin \epsilon_q,$$

with analogous bounds for observable drift (Theorem 4.2).

1. Polynomial Computational Complexity: If each $d_q$ computation costs $O(MC)$ work, the overall pruning cost is $O(NMC)$, and medoid selection by all-pairs distance is $O(N^2 M C)$. There is no exponential scaling with Hilbert space size (Theorem 4.3).

These structural guarantees imply strict control over functional degradation and operational feasibility in the NISQ context.

6. Noise-Calibrated Deformation Parameter

The parameter $\lambda \in [0,1]$ modulates two aspects:

• Non-commutativity: $[T'_i, T'_j] = \lambda^2 [T_i, T_j]$, interpolating between fully commutative and standard quantum regimes.
• Redundancy Thresholds: Because $q(\lambda)$ affects $G_q$ and hence $M_q$ in the $q$-inner product, smaller $\lambda$ (corresponding to higher physical noise) typically increases the spectral bound $M_q$ and reduces the allowed $\epsilon_q$. This results in more conservative pruning under high noise.

In practical scenarios, $\lambda$ is calibrated to match device decoherence characteristics, such as via randomized benchmarking.

7. Empirical Performance and Applicability

q-iPrune was validated on standard QNN benchmarks, including:

• Classification: 8 qubit, depth-12 circuits for MNIST "4 vs 9", Fashion-MNIST "Sandal vs Boot", and synthetic Bars-and-Stripes, with up to 480 gates.
• VQE: 4-qubit transverse-field Ising Model circuits, 240 gates.

Key results (with $\delta=0.01$ and $\sigma=0.001$):

Task	Replacement %	Base Metric	Pruned Metric	Drop
Classification	60%	72.77% acc.	72.90% acc.	−0.13%
TFIM VQE	60%	0.3976 energy	0.3970 energy	$6 \times 10^{-4}$

Higher noise (larger $\sigma$) or tolerance ($\delta$) yields less redundancy and larger (but still bounded) accuracy degradation. In all cases, the experimental accuracy and fidelity drops were well below the theoretical bounds (which are conservative and may be clipped at 100%).

q-iPrune thus delivers substantial circuit compression while certifying retention of task-relevant functionality, with robustness to hardware imperfections via the deformation parameter $\lambda$ (Shao et al., 30 Dec 2025).