Introduction to Qiskit

Welcome to the practical frontier of quantum computing. Up to this point, you have explored the mathematical foundations, the behavior of single qubits, the mechanics of quantum gates, and the abstract architecture of quantum algorithms. However, quantum computing is not merely a theoretical branch of physics; it is an active engineering discipline. To bridge the gap between mathematical abstractions and physical execution, we must use software development kits (SDKs) designed to translate quantum logic into instructions that physical hardware can execute. This topic introduces Qiskit, the most widely used open-source quantum programming framework in the world.

Qiskit, developed by IBM and a global community of contributors, allows developers to design, simulate, and run quantum programs. It provides a high-level interface in Python, enabling you to build quantum circuits without needing to manually calculate statevector transformations or manage the underlying physical control pulses. By learning Qiskit, you transition from a theorist drawing circuit diagrams on paper to a programmer capable of manipulating real quantum states on physical devices located across the globe.

In this topic, you will learn the core architecture of Qiskit 1.x, understand its modular design, and see how it manages the entire quantum workflow from circuit design to execution. You will write your first lines of quantum code and understand how Qiskit acts as the compiler and runtime manager for quantum processors. This sets the foundation for all subsequent hands-on programming topics in this curriculum.

To understand Qiskit, think of it as the software development kit for a highly specialized hardware accelerator, much like CUDA is for NVIDIA GPUs. Just as you do not write raw machine code to render a 3D graphic, you do not write raw microwave pulse sequences to manipulate a qubit. Qiskit acts as the intermediary, translating your high-level Python instructions into the precise physical operations required by quantum hardware.

Another helpful analogy is that of a modern web application architecture. Your Python environment acts as the client-side interface where you design your application (the quantum circuit). Qiskit's transpiler acts as the optimizer that refines your code for a specific server architecture. Finally, the Qiskit Runtime service acts as the cloud backend that executes your job on a remote server (the quantum processor) and returns the results. You do not need to own a quantum computer to run quantum programs; Qiskit brings the quantum computer to your local terminal.

Ultimately, Qiskit organizes the quantum programming workflow into four distinct phases: Design, Transpile, Run, and Analyze. You design circuits using intuitive Python classes, transpile them to match the constraints of specific hardware, run them using local simulators or cloud-based quantum processors, and analyze the resulting statistical data. This structured pipeline ensures that your code remains portable, scalable, and optimized.

Qiskit 1.x is structured around a modular architecture designed to separate circuit construction from execution. The core package, qiskit, provides the fundamental tools for building quantum circuits, representing quantum states, and performing local, high-performance simulations. The execution of these circuits on physical hardware is managed by qiskit_ibm_runtime, which handles cloud-based access to IBM's fleet of superconducting quantum processors.

The fundamental building block in Qiskit is the QuantumCircuit class. A QuantumCircuit object represents a register of qubits and classical bits, along with a sequence of quantum gates applied to them. In Qiskit 1.x, execution is driven by *Primitives*. Primitives are high-level execution interfaces that simplify how developers interact with quantum backends. The two primary primitives are Sampler (which calculates quasi-probability distributions of measurement outcomes) and Estimator (which calculates expectation values of quantum operators).

Here is a complete, runnable Qiskit 1.x program that demonstrates this workflow. It constructs a simple Bell state, simulates its execution locally using the StatevectorSampler, and prints the resulting measurement counts:

from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler

# Step 1: Design the circuit
# We create a circuit with 2 qubits and 2 classical bits
qc = QuantumCircuit(2, 2)
qc.h(0)                    # Apply Hadamard gate to qubit 0
qc.cx(0, 1)                # Apply CNOT gate with control 0 and target 1
qc.measure([0, 1], [0, 1]) # Measure both qubits into classical bits

# Step 2: Instantiate the Sampler primitive
sampler = StatevectorSampler()

# Step 3: Run the circuit
# We submit the circuit to the sampler to run 1024 shots
job = sampler.run([qc], shots=1024)
result = job.result()

# Step 4: Analyze the results
# Retrieve the measurement data for the first (and only) circuit
pub_result = result[0]
counts = pub_result.data.c.get_counts() # 'c' is the default name of the classical register
print("Measurement Counts:", counts)

In this code, StatevectorSampler is a local, noiseless simulator that mimics an ideal quantum computer. The run method returns a Job object, which is executed asynchronously. Calling job.result() blocks execution until the simulation is complete, returning a PrimitiveResult object. We extract the counts from the classical register (automatically named 'c' when initialized implicitly via QuantumCircuit(2, 2)) to see how many times each state was observed.