What is Quantum Programming?

https://www.deeppractise.com/

What is quantum programming ?
Imagine you have a special magic notebook. Whatever you write turns into real magic. Quantum programming is a bit like that — but instead of words, you write code that tells tiny quantum particles (called qubits) how to behave. These qubits can do things ordinary computers can’t.

Simple Example:
Imagine asking a qubit to spin like a coin. When you look at it, it lands heads or tails. But before you look, it spins magically as both heads and tails at once!

Magic notebook writing code → Coin spins in air → Lands heads or tails.

Quantum Programming Basics

Quantum programming means giving instructions to quantum computers using special languages. These instructions help you manipulate qubits, perform quantum gates, and run quantum algorithms.

Example using Qiskit

# Create a quantum coin flip
from qiskit import QuantumCircuit, Aer, transpile
from qiskit.visualization import plot_histogram
from qiskit_aer import AerSimulator

# Prepare a quantum circuit with one qubit
qc = QuantumCircuit(1, 1)

# Apply Hadamard gate (puts qubit in superposition)
qc.h(0)

# Measure the qubit
qc.measure(0, 0)

# Run simulation
simulator = AerSimulator()
compiled_circuit = transpile(qc, simulator)
result = simulator.run(compiled_circuit, shots=1000).result()

# Display results
counts = result.get_counts()
print(counts)

Output example:
{'0': 499, '1': 501}
(The results show approximately half heads '0' and half tails '1', just like flipping a fair coin.)

Circuit diagram → simulator running → histogram of results.

Quantum programming enables direct manipulation of quantum states, entanglement, and quantum parallelism through programmatic interfaces.

Core Concepts:

• Quantum Circuits:
  These are sequences of quantum gates and measurements applied to qubits. Gates like Hadamard (H), Pauli (X, Y, Z), and CNOT form universal gate sets.
• Quantum Superposition:
  Implemented using Hadamard gates, this allows a qubit to simultaneously encode states, exponentially increasing the problem space.
• Quantum Entanglement:
  Gates such as CNOT or CZ create entangled pairs, enabling non-local correlations critical in algorithms like quantum teleportation.

Advanced Qiskit Example: Bell State (Entangled Qubits)

from qiskit import QuantumCircuit, Aer, transpile
from qiskit.visualization import plot_histogram
from qiskit_aer import AerSimulator

# Create Bell state circuit
qc = QuantumCircuit(2, 2)

# Create superposition on qubit 0
qc.h(0)

# Entangle qubit 0 and qubit 1
qc.cx(0, 1)

# Measure qubits
qc.measure([0,1], [0,1])

# Simulate
simulator = AerSimulator()
compiled_circuit = transpile(qc, simulator)
result = simulator.run(compiled_circuit, shots=1000).result()

# Display results
counts = result.get_counts()
print(counts)

Typical Output:
{'00': 504, '11': 496}
(Strong correlation, either both qubits are '00' or both '11', showing entanglement clearly.)

Bell-state circuit → simulation → result showing strong correlation.

How to Start Quantum Programming?

• Install Qiskit:
  pip install qiskit qiskit-aer
• Run examples on:
• IBM Quantum Experience (free online quantum hardware/simulator)
• Google Colab (cloud notebooks for Qiskit/PennyLane)

Hybrid quantum-classical programming combines classical algorithms with quantum circuits. Here’s how it works:

Classical Computers:

• Handle simple calculations, data management, and general logic.
• Optimize quantum circuit parameters.

Quantum Computers:

• Perform specialized quantum tasks (superposition, entanglement).
• Provide computational advantages for specific problems.

Example: Variational Quantum Algorithm (VQE)

The classical computer tweaks quantum circuit parameters to find the lowest energy state of molecules:

import pennylane as qml
from pennylane import numpy as np

dev = qml.device('default.qubit', wires=2)

# Quantum part: Circuit that depends on classical parameters
@qml.qnode(dev)
def circuit(theta):
    qml.RX(theta[0], wires=0)
    qml.RY(theta[1], wires=1)
    qml.CNOT(wires=[0, 1])
    return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))

# Classical part: Optimization loop
theta = np.array([0.1, 0.2], requires_grad=True)
opt = qml.GradientDescentOptimizer(stepsize=0.1)

for _ in range(50):
    theta = opt.step(circuit, theta)

print("Optimized Parameters:", theta)
print("Minimum Energy State:", circuit(theta))

Why Hybrid Quantum-Classical?

Quantum computers alone currently face noise and limited qubits. Hybrid methods use quantum resources efficiently:

Quantum Processor:

• Evaluates quantum states.
• Computes complex quantum observables.

Classical Optimizer:

• Adjusts parameters based on quantum measurements.
• Performs iterative optimization steps.

Example: Quantum Approximate Optimization Algorithm (QAOA)

Optimizing combinational problems like Max-Cut:

import networkx as nx
import pennylane as qml
from pennylane import numpy as np

G = nx.complete_graph(3)
dev = qml.device('default.qubit', wires=3)

def cost_hamiltonian(graph):
    coeffs = [-0.5 for _ in graph.edges()]
    obs = [qml.PauliZ(i) @ qml.PauliZ(j) for i, j in graph.edges()]
    return qml.Hamiltonian(coeffs, obs)

@qml.qnode(dev)
def qaoa_layer(gamma, beta):
    for i in range(3):
        qml.Hadamard(wires=i)
    for edge in G.edges():
        qml.CNOT(wires=edge)
        qml.RZ(2*gamma, wires=edge[1])
        qml.CNOT(wires=edge)
    for i in range(3):
        qml.RX(2*beta, wires=i)
    return [qml.expval(qml.PauliZ(i)) for i in range(3)]

# Classical optimization
gamma, beta = np.array([0.1, 0.2], requires_grad=True)
opt = qml.GradientDescentOptimizer(stepsize=0.05)

for _ in range(100):
    gamma, beta = opt.step(lambda g, b: sum(qaoa_layer(g, b)), gamma, beta)

print("Optimized parameters:", gamma, beta)

Hybrid Workflow (Step-by-Step):

1. Initialization: Classical sets initial parameters.
2. Quantum Execution: Quantum evaluates circuits and returns observables.
3. Classical Optimization: Uses quantum results to update parameters.
4. Iteration: Repeat until convergence.

Variational Quantum Algorithms (VQAs)

What’s a Variational Quantum Algorithm (VQA)?

Get Jay Pandit’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Imagine you have a magic box, and you can adjust some dials on it. You don’t know exactly how it works inside, but by carefully turning the knobs, you eventually get it to do something amazing — like solving a puzzle or finding a hidden treasure.

A Variational Quantum Algorithm is exactly like turning these knobs, but on a quantum computer, to solve difficult problems.

What are Variational Quantum Algorithms (VQAs)?

VQAs are hybrid quantum-classical methods that solve problems by repeatedly running quantum circuits and adjusting their parameters based on classical optimization techniques.

How does it work?

• Quantum part: a quantum circuit with tunable parameters.
• Classical part: optimization algorithm to find the best parameters.

Example: Variational Quantum Eigensolver (VQE)

Finding the lowest-energy state (ground state) of a molecule:

Code Example with PennyLane:

import pennylane as qml
from pennylane import numpy as np

# Setup quantum device
dev = qml.device('default.qubit', wires=2)

# Quantum circuit with parameters
@qml.qnode(dev)
def circuit(params):
    qml.RX(params[0], wires=0)
    qml.RY(params[1], wires=1)
    qml.CNOT(wires=[0,1])
    return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))

# Classical optimization loop
params = np.array([0.1, 0.2], requires_grad=True)
optimizer = qml.GradientDescentOptimizer(stepsize=0.1)

for _ in range(50):
    params = optimizer.step(circuit, params)

print("Optimized parameters:", params)
print("Estimated ground state energy:", circuit(params))

Fundamentals of VQAs

Variational quantum algorithms solve optimization problems by minimizing a cost function:

E(θ)=⟨ψ(θ)∣H∣ψ(θ)⟩

where:

• $\psi(\theta)$: Quantum state generated by parameterized quantum circuit (ansatz).
• $H$: Hamiltonian (operator describing the problem).
• $E(\theta)$: Cost function (energy or problem-specific measure).

Key Variational Algorithms:

• Variational Quantum Eigensolver (VQE)
• Quantum chemistry applications: molecules, materials.
• Minimizes the expectation value of Hamiltonians.
• Quantum Approximate Optimization Algorithm (QAOA)
• Optimization problems (Max-Cut, routing).
• Alternates problem (cost) Hamiltonian and mixer Hamiltonian.

Advanced QAOA Example with PennyLane:

import pennylane as qml
import networkx as nx
from pennylane import numpy as np

G = nx.cycle_graph(3)  # Example graph (triangle)

dev = qml.device('default.qubit', wires=3)

def cost_hamiltonian(graph):
    coeffs = [-1 for _ in graph.edges()]
    obs = [qml.PauliZ(i) @ qml.PauliZ(j) for i,j in graph.edges()]
    return qml.Hamiltonian(coeffs, obs)

H_cost = cost_hamiltonian(G)

@qml.qnode(dev)
def circuit(params):
    for i in range(3):
        qml.Hadamard(wires=i)

    gamma, beta = params
    qml.ApproxTimeEvolution(H_cost, gamma, 1)
    for i in range(3):
        qml.RX(2 * beta, wires=i)
    
    return qml.expval(H_cost)

# Classical optimization loop
params = np.array([0.1, 0.1], requires_grad=True)
optimizer = qml.GradientDescentOptimizer(0.05)

for _ in range(100):
    params = optimizer.step(circuit, params)

print("Optimized parameters:", params)
print("Minimum Cost:", circuit(params))

Challenges and Advanced Solutions:

Barren Plateaus:

• Optimization landscapes become flat, hindering parameter tuning.
• Solution: Special initialization, layered circuits, entanglement-aware designs.

Noise resilience:

• Quantum hardware noise can distort optimization.
• Solution: Error mitigation techniques (zero-noise extrapolation).

Workflow of VQAs:

1. Initialize random parameters $\theta$.
2. Run quantum circuit and measure observable.
3. Compute cost function.
4. Classical optimizer adjusts $\theta$.
5. Iterate until convergence.