3 minute read 

/*
A simple hello-world-looking quantum program
... that actually does nothing.
*/
OPENQASM 2.0;

qreg hello[1];
creg world[1];

measure hello -> world;

(This is my attempt at writing a “Hello, world!” program in OpenQASM. While it doesn’t compute anything meaningful, it introduces basic syntax.)

Programming Quantum Circuits

In classical computing, programming ranges from low-level hardware description languages (HDLs) and assembly to high-level languages and frameworks. Similarly, quantum computing has its own ecosystem of languages and tools made for the unique nature of quantum systems.

As we explored in the earlier articles (e.g., Deutsch-Jozsa and Shore’s algorithms), quantum algorithms today are still primarily designed at the circuit level. This means we construct sequences of quantum gates to manipulate qubits, much like building logic circuits in classical computing. While this low-level approach allows precise control, it also reflects the early stages of quantum programming. Higher-level abstractions, similar to classical programming languages, are still rare but slowly emerging as the field matures.

OpenQASM: The Language for Quantum Circuits

OpenQASM (Quantum Assembly Language), developed by IBM, is an open-source language that lets you specify quantum circuits in a standardized way. It’s like the assembly language of quantum computing, giving you precise control the quantum operations.

It’s not quite like a hardware description language (HDL) since it doesn’t describe the hardware itself, Instead, OpenQASM is all about specifying the sequence of operations to run on a quantum computer, making it more like an assembly language for quantum systems.

A Simple Circuit in OpenQASM

Let’s look at a basic example: a two-qubit circuit that applies a Hadamard gate, a CNOT gate, and then measures the qubits. Here’s the diagram of the circuit:

quantum-circuit

This two-qubit circuit can be described in OpenQASM (version 2.0) as follows:

OPENQASM 2.0;

qreg q[2];
creg c[2];

h q[0];
cx q[0], q[1];

measure q -> c;

Here’s what’s happening in this OpenQASM code:

  • OPENQASM 2.0; specifies the version of the OpenQASM language being used.
  • qreg q[2]; defines a quantum register q with two qubits.
  • creg c[2]; defines a classical register c with two bits.
  • h q[0]; applies a Hadamard gate to the first qubit.
  • cx q[0], q[1]; applies a CNOT gate with the first qubit as the control and the second qubit as the target.
  • measure q -> c; performs a measurement on the qubits and stores the results in the classical registers.

As you can see, OpenQASM makes it easy to describe quantum circuits in a structured and readable way.

Why OpenQASM 2.0?

One may wonder why we’re not using OpenQASM 3.0. While OpenQASM 3.0 introduces exciting new control flows (unbounded loops!) and more expressive gate definitions, it’s still under development. On the other hand, OpenQASM 2.0 is stable and widely supported, making it the go-to standard for most quantum computing platforms today.

Current Limitations and Future Directions

Today, quantum programming focuses heavily on circuit-level design, driven by the field’s early stage of development. Some higher-level quantum programming languages, like Silq and Quipper, are emerging, but they are not yet widely adopted.

As the field evolves, we can expect the introduction of more high-level quantum programming languages allowing quantum programs to be expressed in ways that hide the complexity of circuit-level programming. This mirrors the historical progression of classical computing, where high-level languages replaced low-level programming for most applications.

For now, though, circuit-level design remains the dominant paradigm for quantum programming, and languages like OpenQASM are essential for researchers and developers in the field.

From Circuits to Quantum Backends

So far, we’ve explored quantum circuit programming using OpenQASM, a language designed to specify quantum algorithms at the circuit level. However, designing a quantum circuit is only part of the story. To run these circuits on actual quantum computers or simulators, we need tools that acts as a bridge between written program and the physical or simulated backend. This is where quantum programming frameworks come into play.

In the next article, we’ll dive into Qiskit–a powerful and widely-used quantum programming framework–and see how it makes quantum programming accessible to everyone.

Leave a comment

You may also enjoy