How Qiskit Works: Circuits, Algorithms, and Mid-Circuit Collapse

Qiskit is IBM's open-source quantum programming framework that allows users to design, simulate, and execute quantum circuits on simulators and real quantum hardware. Qiskit abstracts the gate-based model of quantum computing and provides full-stack support for writing quantum programs, optimizing them, and running them on actual superconducting qubit devices.

In this article, we explore how Qiskit works, dive deep into important quantum algorithms, and explain how mid-circuit measurement and collapse are used in practical quantum computation.

1. Quantum Circuits in Qiskit

At the core of Qiskit is the quantum circuit model, built from:

• Qubits: Two-level quantum systems represented as complex linear combinations of basis states $|0\rangle$ and $|1\rangle$.
• Gates: Unitary operations acting on qubit states, such as Hadamard (H), Pauli-X (X), and controlled-NOT (CNOT).
• Measurements: Projective operations that collapse qubits into classical bit values.

A quantum state $|\psi\rangle$ in n-qubits is a vector in $\mathbb{C}^{2^n}$:

$|\psi\rangle = \sum_{i=0}^{2^n-1} \alpha_i |i\rangle, \text{ with } \sum |\alpha_i|^2 = 1$

2. Qiskit Code: Basic Circuit Example

python
from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2)
qc.h(0)            # Hadamard gate on qubit 0
qc.cx(0, 1)        # CNOT from qubit 0 to 1
qc.measure([0,1], [0,1])  # Measure both qubits
qc.draw('mpl')

3. Mid-Circuit Measurement and Collapse

Qiskit supports mid-circuit measurement, where a qubit is measured before the end of the program, and the result is used to influence subsequent quantum operations. This mimics quantum collapse during computation and enables adaptive algorithms.

Mathematical Form

Let a 1-qubit state be:

$|\psi\rangle = \alpha |0\rangle + \beta |1\rangle$

Measuring collapses it into:

• $|0\rangle$ with probability $|\alpha|^2$, or
• $|1\rangle$ with probability $|\beta|^2$

Post-measurement, the system evolves only based on the collapsed state.

python
from qiskit import QuantumCircuit, Aer, execute

qc = QuantumCircuit(1, 1)
qc.h(0)               # Create superposition
qc.measure(0, 0)      # Collapse mid-circuit
qc.x(0).c_if(0, 1)    # Apply X gate only if measurement was 1
qc.draw('mpl')

4. Transpilation and Execution

Qiskit transpiles circuits to match the topology and native gates of real hardware. This includes:

• Qubit routing (inserting SWAP gates)
• Gate decomposition into hardware-native basis gates
• Optimization for depth, fidelity, or execution time

python
from qiskit import transpile
transpiled_qc = transpile(qc, backend=backend)

5. Simulators and Noise Modeling

With Qiskit Aer, users can simulate:

• Ideal state evolution with StatevectorSimulator
• Probabilistic sampling with QasmSimulator
• Noisy behavior using hardware-calibrated noise models

python
from qiskit.providers.aer import AerSimulator
sim = AerSimulator()
result = sim.run(transpiled_qc).result()
print(result.get_counts())

6. Quantum Algorithms in Qiskit

6.1 Shor's Algorithm (Integer Factoring)

Shor's algorithm finds the period $r$ of a function $f(x) = a^x \bmod N$ using quantum Fourier transform (QFT).

Key Step:

$\frac{1}{\sqrt{2^n}} \sum_{x=0}^{2^n-1} |x\rangle |f(x)\rangle \to \text{Measure } |f(x)\rangle \to \text{QFT on } |x\rangle$

python
from qiskit.algorithms import Shor
shor = Shor()
result = shor.factor(N=15)
print(result.factors)

6.2 Grover's Algorithm (Unstructured Search)

Grover's algorithm amplifies the amplitude of the correct solution using oracle + diffusion steps.

Ideal query time: $O(\sqrt{N})$ compared to classical $O(N)$

Circuit Outline:

1. Initialize to equal superposition
2. Apply Oracle $O_f$
3. Apply Diffusion operator
4. Repeat $\sim\sqrt{N}$ times

python
from qiskit.algorithms import Grover, AmplificationProblem
oracle = QuantumCircuit(3)
oracle.cz(0, 2)
oracle.cz(1, 2)

problem = AmplificationProblem(oracle)
grover = Grover()
result = grover.amplify(problem)
print(result)

6.3 VQE (Variational Quantum Eigensolver)

VQE estimates the ground state energy of a Hamiltonian:

$H = \sum_i \alpha_i P_i, \text{ where } P_i \in \{I, X, Y, Z\}^{\otimes n}$

1. Define parameterized circuit $|\psi(\theta)\rangle$
2. Classically optimize $E(\theta) = \langle\psi(\theta)|H|\psi(\theta)\rangle$
3. Use quantum device to evaluate expectation values

python
from qiskit.algorithms import VQE
from qiskit.circuit.library import TwoLocal
from qiskit.opflow import Z, I, X
from qiskit.algorithms.optimizers import COBYLA

ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz', reps=2)
hamiltonian = (Z ^ I) + (I ^ Z) + 0.5 * (X ^ X)
vqe = VQE(ansatz=ansatz, optimizer=COBYLA())
result = vqe.compute_minimum_eigenvalue(hamiltonian)
print(result.eigenvalue)

6.4 QAOA (Quantum Approximate Optimization)

QAOA solves combinatorial problems (e.g., Max-Cut) by evolving under:

$U(\gamma, \beta) = \prod_{l=1}^p e^{-i\beta_l H_M} e^{-i\gamma_l H_C}$

Where:

• $H_C$: Cost Hamiltonian (encodes the problem)
• $H_M$: Mixer Hamiltonian (e.g., sum of X gates)

7. Real Hardware Execution

Qiskit lets you run jobs on real IBM quantum processors:

python
from qiskit import IBMQ
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_qasm_simulator')  # or real backend

from qiskit import execute
job = execute(qc, backend=backend, shots=1024)
result = job.result()
counts = result.get_counts()
print(counts)

Algorithm Comparison Table

Summary

Qiskit is a powerful toolchain for building, simulating, optimizing, and executing quantum circuits. It supports:

• Gate-level circuit construction
• Mid-circuit measurement and conditional logic
• Quantum algorithm libraries (Shor, Grover, VQE, QAOA)
• Transpilation and noise-aware simulation
• Real quantum hardware execution via IBMQ

Its support for mid-circuit collapse and measurement-based adaptivity makes Qiskit well-suited for designing quantum feedback systems, dynamic algorithms, and hybrid quantum-classical workflows.

Whether you're exploring quantum supremacy, developing quantum machine learning models, or building quantum applications for optimization and simulation, Qiskit provides the comprehensive framework needed to bridge theoretical quantum computing with practical implementation.

Related Reading:

• Quantum Collapse: From Superposition to Certainty
• Bayesian Collapse in Quantum Monadics
• The Collapse Engine: Modeling Quantum Consciousness Through Code