Parameterized Quantum Circuits (PQCs), often called ansätze (from the German word for "approach" or "setup"), form the heart of Variational Quantum Algorithms. As outlined in the chapter introduction, VQAs use a classical optimizer to tune the parameters of a quantum circuit. The PQC is precisely this tunable quantum circuit. Its role is to transform an initial state, typically prepared by encoding classical data $\vec{x}$ , into a final state $|\psi(\vec{x}, \vec{\theta})\rangle$ . Measurements performed on this final state are then used to compute a cost function $C(\vec{\theta})$ , which the classical optimizer seeks to minimize by adjusting the parameters $\vec{\theta}$ .

Formally, a PQC $U(\vec{\theta})$ is a unitary operation composed of a sequence of quantum gates, some of which depend on tunable classical parameters $\vec{\theta} = (\theta_1, \theta_2, \dots, \theta_M)$ . Often, the overall circuit in a VQA for machine learning takes the form:

|\psi(\vec{x}, \vec{\theta})\rangle = U(\vec{\theta}) U_{\text{encode}}(\vec{x}) |0\rangle^{\otimes n}

Here, $U_{\text{encode}}(\vec{x})$ is the data encoding circuit (discussed in Chapter 2) that maps the classical input data $\vec{x}$ onto an initial quantum state, usually starting from the $|0\rangle^{\otimes n}$ state for $n$ qubits. The PQC $U(\vec{\theta})$ then further processes this state. The design of $U(\vec{\theta})$ is a critical factor determining the VQA's performance and involves several strategic considerations.

Design Considerations for PQCs

Choosing an appropriate PQC architecture involves balancing several competing factors:

Expressibility: How well can the PQC explore the Hilbert space? A highly expressive PQC can, in principle, approximate a wider variety of target functions or distributions. If the PQC can generate states uniformly across the Hilbert space (approaching the Haar measure), it's considered highly expressive. However, high expressibility isn't always desirable. It can make the optimization landscape more complex and increase the susceptibility to barren plateaus (which we'll discuss later in this chapter). Furthermore, the necessary expressibility is task-dependent; simpler tasks might not require the PQC to access the entire Hilbert space.
Entangling Capability: The ability of the PQC to generate entanglement between qubits is often considered important for capturing complex correlations within data that might be difficult for classical models. Ansätze that lack sufficient entangling gates might be efficiently simulable classically, limiting their potential for quantum advantage. The pattern and frequency of entangling gates within the PQC structure directly influence this capability.
Trainability: How easily can the classical optimizer find good parameters $\vec{\theta}$ ? This is closely linked to the structure of the cost function landscape. Deep circuits, certain gate choices, global cost functions, and high levels of entanglement can contribute to the emergence of barren plateaus, where gradients vanish exponentially with the number of qubits, making optimization extremely difficult. Shallow circuits with local cost functions are generally preferred for better trainability on near-term hardware. The choice of parameterized gates also matters; gates whose gradients can be computed efficiently using methods like the parameter-shift rule (e.g., single-qubit rotations) are often favored.
Hardware Efficiency: Given the limitations of Noisy Intermediate-Scale Quantum (NISQ) devices, PQCs should ideally be implementable with low circuit depth and use quantum gates that are native to the specific hardware platform. This minimizes the impact of decoherence and gate errors. Reducing the number of non-native gates avoids costly decomposition into native gates, which increases both depth and error accumulation. Minimizing two-qubit gates is particularly important as they typically have higher error rates than single-qubit gates.

Common Ansatz Structures

While the optimal ansatz is problem-dependent, several common design strategies have emerged:

Hardware-Efficient Ansätze

These are arguably the most common type of PQC used in near-term applications. They are designed with hardware limitations in mind, prioritizing shallow depth and using easily implementable gates, rather than being directly inspired by the problem domain. A typical structure consists of repeating layers, where each layer contains:

A sub-layer of parameterized single-qubit rotations applied to all (or a subset of) qubits. Common choices include combinations of $R_x(\theta)$ , $R_y(\phi)$ , and $R_z(\gamma)$ .
A sub-layer of fixed two-qubit entangling gates (e.g., CNOT or CZ) arranged in a specific pattern. Common patterns include linear (neighboring qubits), circular (neighboring with wrap-around), or all-to-all connectivity (if hardware allows, although often decomposed).

The number of layers determines the circuit depth and the number of parameters. Increasing layers generally increases expressibility but also makes the circuit harder to train and more susceptible to noise.

A simple 3-qubit hardware-efficient ansatz with two layers. Each layer consists of parameterized single-qubit rotations ( $R_y, R_z$ ) followed by linear CNOT entanglement.

Problem-Inspired Ansätze

In some cases, the structure of the problem might suggest a specific PQC design. For example, in quantum chemistry simulations using VQE, ansätze like Unitary Coupled Cluster Singles and Doubles (UCCSD) are inspired by physical principles. While less common in general machine learning tasks, if an ML problem can be mapped effectively onto a physical system or Hamiltonian, specialized ansätze might offer advantages in terms of requiring fewer parameters or having better convergence properties for that specific problem. However, these are often less "hardware-efficient" than the layered structures described above.

Tensor Network Ansätze

Drawing inspiration from tensor network methods used in condensed matter physics and classical machine learning, PQCs based on structures like Matrix Product States (MPS) or Tree Tensor Networks (TTN) can be constructed. These ansätze typically exhibit controlled entanglement growth and can be efficient in terms of the number of parameters, particularly for representing states with limited entanglement. This constrained structure might help mitigate barren plateaus in some scenarios, but it might also limit their expressibility for problems requiring highly entangled states.

Balancing the Trade-offs and Practical Advice

Designing a PQC is an iterative process involving careful consideration of the trade-offs:

Start Simple: Begin with a shallow hardware-efficient ansatz (e.g., 1-2 layers).
Evaluate Performance: Train the VQA and assess its performance on your task.
Iterate: If performance is insufficient, consider:
- Increasing Depth: Add more layers to enhance expressibility, but monitor trainability closely.
- Modifying Entanglement: Try different entangling patterns (e.g., linear vs. circular vs. full) based on hardware connectivity and potential data structure.
- Changing Gates: Experiment with different single-qubit rotation combinations.
- Revisiting Encoding: Remember that the data encoding $U_{\text{encode}}(\vec{x})$ and the PQC $U(\vec{\theta})$ work together. An ineffective encoding can hinder even a well-designed PQC. Techniques like data re-uploading (Chapter 2), which interleave encoding and parameterized layers, can be considered part of the overall PQC design strategy.

Tools exist within quantum software libraries (like Qiskit, Pennylane) to help quantify ansatz properties like expressibility and entangling capability, although these analyses can be computationally expensive. Ultimately, empirical testing guided by an understanding of these design principles is often the most practical approach for finding effective PQCs for specific machine learning tasks on near-term hardware. The rest of this chapter will build upon this foundation, examining how to define cost functions, calculate gradients for these parameterized circuits, and perform the optimization step.