Modern Quantum Programming: Building with Patterns, Not Gates

Modern quantum programming has evolved beyond gate-level circuit design. Today, you can solve complex optimization problems on real quantum hardware by leveraging standard algorithmic design patterns that abstract away circuit complexity entirely.

This article looks at how a simple placement optimiser problem running on IBM quantum computers uses quantum algorithm design patterns to bridge the gap between mathematical problem formulation and physical hardware execution, without requiring manual circuit design.

The Pattern-Based Approach: Math to Hardware Translation

Instead of building quantum circuits from scratch, modern quantum programming follows a pattern-based workflow that mirrors classical software engineering:

1. Formulate the problem mathematically using standard formats such as Quadratic Unconstrained Binary Optimization (QUBO)
2. Select a standard quantum algorithm as a template (VQE, QAOA)
3. Let the algorithmic pattern handle circuit complexity automatically
4. Execute on real quantum hardware with hardware-aware compilation

This approach uses three key design patterns working in concert:

Design Pattern 1: Universal Problem Formulation (QUBO)

The first pattern is problem abstraction. We express the fire extinguisher placement problem in a universally recognized format: QUBO (Quadratic Unconstrained Binary Optimization).

qp = QuadraticProgram()
qp.binary_var_list(num_rooms)  # One binary variable per room 

# Objective: minimize danger 
for room in rooms: 
    qp.minimize(linear={room: danger_scores[room]}) 

# Constraint: exactly 5 extinguishers 
qp.linear_constraint(linear={room: 1 for room in rooms}, sense='==', rhs=5)        

QUBO is the quantum equivalent of SQL, a domain-specific language that works with dozens of different solvers. The same formulation can be solved by:

• VQE (Variational Quantum Eigensolver)
• QAOA (Quantum Approximate Optimization Algorithm)
• Quantum Annealing
• Grover's Search
• Even classical solvers for comparison

This abstraction separates "what to solve" from "how to solve it," just like you write SQL queries without implementing database internals.

Design Pattern 2: Parameterised Quantum Circuit (Ansatz)

The second pattern is the ansatz, a parameterized quantum circuit template that explores the solution space. Instead of designing custom gates, we use pre-built circuit architectures:

# Build circuit template with standard architecture
num_qubits = qp.get_num_binary_vars()

# EfficientSU2: a proven ansatz pattern for optimization
ansatz = EfficientSU2(
    num_qubits=num_qubits, 
    reps=self.ansatz_reps,  # Depth of circuit layers
    entanglement='linear'    # Qubit connectivity pattern
)

# Fallback to alternative pattern
except:
    ansatz = RealAmplitudes(num_qubits=num_qubits, reps=self.ansatz_reps)        

The ansatz pattern provides:

• Rotation gates (adjustable parameters to explore solutions)
• Entanglement gates (quantum correlations between qubits)
• Linear topology (respects hardware connectivity)
• Configurable depth (balances expressiveness vs. noise)

This is a template pattern in software engineering terms, a reusable structure where specifics can vary (number of qubits, depth, connectivity) while the overall architecture remains proven and reliable.

EfficientSU2 creates a circuit with rotation gates (that can be tuned) interleaved with entangling gates (that create quantum correlations). The reps parameter determines depth: more reps mean more expressivity but also more noise. The code includes a fallback to RealAmplitudes if EfficientSU2 fails.

The linear entanglement pattern connects qubits in a chain rather than all-to-all, respecting the hardware topology. Then we transpile this ansatz to match the backend's instruction set architecture (ISA), this is crucial for actually running on real hardware.

Design Pattern 3: Hardware-Aware Transpilation

The third pattern bridges the gap between ideal quantum circuits and physical hardware reality:

# Transpile pass manager
pm = generate_preset_pass_manager(
    optimization_level=3,  # Maximum optimization effort
    backend=self.backend   # Target quantum processor
)

# Transform ideal circuit to hardware-compatible version
ansatz_isa = pm.run(ansatz)        

The transpilation handles:

• Gate decomposition: Breaking ideal gates into hardware-native operations
• Qubit routing: Mapping logical qubits to physical qubits based on connectivity
• Error mitigation: Choosing gate sequences that minimize noise
• Calibration awareness: Using current hardware performance data

The transpiler is a compiler pattern, translating high-level abstractions into machine-specific instructions, much like gcc compiles C to x86 assembly.

Connecting the Patterns: The Translation Pipeline

Here's how these three patterns work together to translate mathematics to hardware:

Step 1: Mathematical Problem → Quantum Operator

# Convert QUBO to quantum-native representation
qp2qubo = QuadraticProgramToQubo(penalty=100.0)
qubo = qp2qubo.convert(qp)
op, offset = qubo.to_ising()
        

Our constraints (like "exactly 5 extinguishers") become penalty terms in the quantum operator. Violating constraints increases energy dramatically, guiding the quantum system toward valid solutions.

Step 2: Quantum Operator → Hardware Layout

# Align operator with transpiled circuit layout 
op_isa = op.apply_layout(ansatz_isa.layout)        

After transpilation, logical qubit 0 might map to physical qubit 5. This step ensures measurements are interpreted correctly—a crucial detail that's easy to miss but breaks everything if omitted.

Step 3: Quantum Execution Environment

# Set up reproducibility and sampling 
algorithm_globals.random_seed = 42 
# Create Sampler for quantum measurements sampler = Sampler(mode=self.backend, options={"default_shots": 4096})        

The Sampler pattern abstracts the messy details of quantum measurement:

• Running circuits thousands of times (dealing with quantum randomness)
• Collecting measurement statistics
• Interfacing with remote quantum hardware
• Handling execution queues and job management

Step 4: Hybrid Quantum-Classical Loop (VQE Pattern)

# SPSA: optimizer designed for noisy quantum hardware
optimizer = SPSA(maxiter=self.vqe_maxiter)

# VQE: the core algorithmic pattern
vqe = SamplingVQE(sampler=sampler, ansatz=ansatz_isa, optimizer=optimizer)

# Execute hybrid loop
vqe_result = vqe.compute_minimum_eigenvalue(op_isa)        

VQE (Variational Quantum Eigensolver) is a strategy pattern that alternates between:

1. Quantum execution: Run parameterized circuit → measure energy
2. Classical optimization: Analyze results → update parameters
3. Repeat: Iteratively minimize energy (find optimal solution)

The SPSA optimizer is specifically designed for noisy function evaluations, required for current quantum hardware where measurements have inherent uncertainty.

Step 5: Post-Processing Pattern

Finally we have a repair pattern that deal solutions that don't always satisfy the constraints perfectly, for example caused by the hardware limitations of current.

The pattern:

1. Attempts to find valid solutions in measurement results
2. Falls back to greedy repair if necessary
3. Always returns a constraint-satisfying answer

Why This Pattern-Based Approach Matters

Abstraction Enables Accessibility

Ten years ago, running this optimisation would have required expertise in:

• Quantum error correction
• Manual gate decomposition
• Hardware calibration procedures
• Low-level circuit optimization

Today, Qiskit function generate_preset_pass_manager handles most of this automatically. The design patterns abstract complexity, making quantum programming accessible to domain experts who aren't quantum physicists.

Understanding the Patterns Remains Valuable

While tools continue to improve, understanding the underlying patterns helps you:

• Debug effectively when things go wrong
• Optimize performance for your specific problem class
• Design new algorithms or adapt existing patterns
• Make informed decisions about when quantum computing is appropriate
• Interpret results correctly, understanding limitations

Conclusion: From Mathematics to Hardware Through Patterns

Modern quantum programming isn't about designing individual quantum gates, it's about:

1. Expressing problems in universal formats (QUBO)
2. Selecting proven algorithmic patterns (VQE, QAOA)
3. Leveraging automated hardware compilation (transpilation)
4. Understanding the translation pipeline (problem → operator → circuit → hardware)

This pattern-based approach mirrors the evolution of classical programming: from assembly language to high-level languages to frameworks. We're building abstractions that let domain experts solve real problems on quantum hardware without needing detailed knowledge in quantum mechanics.

The future of quantum programming is becoming less about quantum circuit design and more about knowing which patterns to apply and understanding how they translate to hardware execution. Just like modern software developers rarely write assembly code, future quantum programmers will rarely design gates manually, they'll compose proven patterns to solve real-world problems.

The quantum computing revolution isn't just about better hardware, it's about better abstractions.