OpenQASM Quantum Circuits

This course is not a glossary of quantum mechanics. You will learn a quantum circuit as a procedure: prepare an input, operate on it, and read a 0 or 1 at the end. Rather than memorizing abstract words, the goal is to predict what happens when you run the same circuit many times.

The overall learning order

The six-step template used throughout

• •See the result: what you measure and how many 0s and 1s appear.
• •Name it: attach new vocabulary only to an observed result or a calculation step.
• •Follow the numbers: update the state's numbers one line at a time.
• •Follow the circuit: trace the same operation from left to right.
• •Follow the OpenQASM: trace the same operation from top to bottom.
• •Predict: answer the result before running, then confirm it.

0.1 Start with an ordinary bit

A bit in an ordinary computer is either 0 or 1 the instant you read it. A representative implementation reads low voltage as 0 and high voltage as 1. Here we ignore the physical method and use only 'an answer that is a single 0-or-1 digit'.

0.2 A quantum circuit also returns 0 or 1 at the end

A qubit can hold more states than a classical bit along the way. But when you measure it the usual way at the end, a single run yields just one answer, 0 or 1. The first key point is not to confuse the intermediate state with the answer you can finally read.

0.3 A circuit diagram is a timetable of operations

One horizontal line is the flow of time for one qubit. The left is the start, the right is the end. A box on the line is an instruction that changes the state at that point. You read 0/1 at the position of the measurement symbol.

0.4 OpenQASM writes the same procedure as text

OPENQASM 3.1;
include "stdgates.inc";
qubit q;
bit result;
result = measure q;

0.5 The first experiment

1.1 First, just look at the result

Apply X once

1.2 Applying X twice

|0> → X → |1> → X → |0>. Because it returns to the start, X is its own inverse.

OPENQASM 3.1;
include "stdgates.inc";
qubit q;
bit result;
x q;
result = measure q;

2.1 One result alone cannot tell you the ratio

To learn whether a given preparation tends to give 0 or 1, run the same program from the start many times. Each run is an independent experiment that prepares a fresh qubit.

2.2 Separate the roles of OpenQASM and the execution service

OpenQASM describes 'what one program does'. Setting up a 1000-shot run, choosing the target simulator or hardware, and building the tally chart are usually the job of the SDK or execution service.

3.1 The state card [a, b]

We record the pre-measurement state of one qubit with two numbers, [a, b]. The left value a is the 0-side number; the right value b is the 1-side number. In this course we use real numbers only, at first.

3.2 Don't fear √2

√2 is 'the positive number that squares to 2', about 1.414. 1/√2 is about 0.707, and squares to 1/2. So [1/√2, 1/√2] is a state card that gives 0 and 1 with 50% each.

3.3 A negative amplitude still gives a positive probability

For [1/√2, -1/√2] too, squaring gives 1/2 on both the 0-side and the 1-side. If you measure right away, plus versus minus is invisible in the count distribution. But later gates add and subtract amplitudes, so a difference in sign can turn into a different measurement result.

4.1 The H rule has two parts

The H gate makes two new amplitudes from the input's 0-side amplitude a and 1-side amplitude b. The new 0-side is (a+b)/√2, and the new 1-side is (a−b)/√2. At first, just plug numbers into these formulas.

4.2 Apply H to |0>

The state card of |0> is [1,0]. The 0-side is (1+0)/√2 = 1/√2, and the 1-side is (1−0)/√2 = 1/√2. So H|0> = [1/√2, 1/√2]. Measuring gives 0 and 1 with 50% each.

4.3 Apply H to |1>

|1> is [0,1]. The 0-side is (0+1)/√2 = 1/√2, and the 1-side is (0−1)/√2 = −1/√2. So H|1> = [1/√2, −1/√2]. A standard measurement right after is still 50:50, but the sign differs.

OPENQASM 3.1;
include "stdgates.inc";
qubit q;
bit result;
h q;
result = measure q;

4.4 Apply H twice

Apply H again to |+> = [1/√2, 1/√2]. The new 0-side is (1/√2 + 1/√2)/√2 = 1, and the new 1-side is (1/√2 − 1/√2)/√2 = 0. The result is [1,0] = |0>. H is also its own inverse.

5.1 The Z rule

The Z gate changes the state card [a,b] to [a,−b]. It leaves the 0-side unchanged and flips the sign of the 1-side amplitude only.

5.2 Why [0,−1] also measures as 1

Because P(0) = 0² = 0 and P(1) = (−1)² = 1. [0,−1] and [0,1], which differ by the same overall −, cannot be told apart by any measurement. On the other hand, [1/√2,1/√2] and [1/√2,−1/√2] differ in the sign relation between the two components, and a later H can tell them apart.

5.3 Compute H-Z-H line by line

5.4 Now, for the first time, we call it 'interference'

In the last H, to make the new 0-side amplitude we added 1/√2 and −1/√2. The result is 0. On the 1-side we subtracted −1/√2 from 1/√2, so the result is 1. When several amplitudes enter the amplitude calculation of the same output and grow or cancel to 0 through addition or subtraction, we call it interference.

OPENQASM 3.1;
include "stdgates.inc";
qubit q;
bit result;
h q;
z q;
h q;
result = measure q;

6.1 A measuring device needs answer labels

A standard measure returns whether the state reads as |0> or |1>. But if you want to tell |+> from |->, place an H just before the standard measurement, because H|+> = |0> and H|-> = |1>.

// Prepare |-> and measure in the X basis
x q;
h q;
// X-basis measurement
h q;
result = measure q;

7.1 Two classical bits have four cases

Line up two bits and there are four cases: 00, 01, 10, 11. A two-qubit measurement result, in one shot, is also one of these four. With three qubits there are 2³ = 8 cases, from 000 to 111.

7.2 The two-qubit state card

For two qubits we line up four amplitudes, one for each candidate 00, 01, 10, 11. This book writes them in the order [q[0]q[1]], so the state card is [a00, a01, a10, a11].

7.3 Index order and display order are separate issues

This book writes bit strings in the order q[0]q[1]. However, an SDK or execution service may display the result string in the order q[1]q[0]. Don't guess the meaning; confirm the display rule with a minimal test that places a single X.

OPENQASM 3.1;
include "stdgates.inc";
qubit[2] q;
bit[2] c;
x q[0];
c = measure q;

8.1 The rule is 'if the control is 1, apply X to the target'

8.2 Apply the same rule across the whole state card

When a state has amplitudes on multiple candidates, apply the four-row table to each candidate. For example, [1/√2,0,1/√2,0] is 00 and 10 at 50:50. Applying CX q[0],q[1] moves 00 to 00 and 10 to 11, giving [1/√2,0,0,1/√2].

OPENQASM 3.1;
include "stdgates.inc";
qubit[2] q;
bit[2] c;
x q[0];
cx q[0], q[1];
c = measure q;

8.3 Swapping the arguments is a different circuit

For the same input |10>, cx q[1],q[0] does nothing because the control q[1] is 0, leaving |10>. The control and target lines cannot be exchanged.

9.1 After H, apply CX

9.2 Look at 'each qubit alone' and it's 50:50

Since 00 and 11 are half each, q[0] alone is 0/1 at 50:50, and q[1] alone is 0/1 at 50:50. But looking at the two together, 01 and 10 never appear and the values always match. The individual ratios alone cannot express the overall relationship.

9.3 CX is not a copier of an unknown state

When the control is |0> or |1>, CX seems to align the target to the same Z-basis value. But if the control is |+>, the output is a Bell state, not 'control |+>, target |+>'. It has not made two copies of the same single-qubit state.

OPENQASM 3.1;
include "stdgates.inc";
qubit[2] q;
bit[2] c;
h q[0];
cx q[0], q[1];
c = measure q;

10.1 One line is, in principle, one statement

10.2 Indices start from 0

For qubit[3] q; the usable indices are 0, 1, 2. q[3] means the fourth element, which is out of range. Distinguish the count 3 from the maximum index 2.

10.3 Comments are explanations that are not executed

// Everything to the right on this line is a line comment
x q[0];  // flip q[0]
/* A multi-line
   comment */

10.4 A complete Bell program

OPENQASM 3.1;
include "stdgates.inc";
qubit[2] q;
bit[2] c;
h q[0];
cx q[0], q[1];
c = measure q;

11.1 Measurement is not only at the end

You can measure a qubit mid-circuit and save the result into a bit. Depending on whether that bit is 0 or 1, some systems let you change the later gates.

11.2 reset re-prepares to |0>

reset q[0];

11.3 Check a classical bit with if

bit m;
m = measure q[0];
if (m == 1) {
  x q[1];
}

11.4 Once measured, the original superposition does not remain

For example, measuring |+> gives 0 or 1. If the result is 0 the post-measurement state is |0>; if 1, it is |1>. Measuring the same qubit again with a standard measurement gives, ideally, the same value.

12.1 A type decides how a value is used

12.2 input receives a value from outside the circuit

input angle theta;
output bit result;
qubit q;
ry(theta) q;
result = measure q;

12.3 for is a repetition with a fixed count

qubit[4] q;
for int i in [0:3] {
  h q[i];
}

i changes as 0, 1, 2, 3, applying H once to each of the four qubits. [0:3] includes the endpoint 3.

12.4 while repeats while the condition is true

bit success = 0;
while (success == 0) {
  reset q;
  h q;
  success = measure q;
}

13.1 + and − are phases of 0° and 180°

So far we treated amplitudes as real numbers and used only + and −. If you think of + as the 0° direction and − as the 180° direction, the sign is two special cases of phase. General quantum circuits also use intermediate directions such as 45° or 90°.

13.2 RY moves continuously from 0 to 1

Applying RY(θ) to |0> gives cos(θ/2)|0> + sin(θ/2)|1>. θ=0 gives |0>, θ=π/2 gives 0/1 at 50:50, and θ=π gives |1>. π is 180°, so π/2 is 90°.

13.3 The roles of RX, RZ, RZZ

13.4 gate names a sequence of quantum operations

gate make_bell a, b {
  h a;
  cx a, b;
}
qubit[2] q;
make_bell q[0], q[1];

13.5 Modifiers change how an existing gate is used

13.6 def is a general subroutine

def parity(bit[4] x) -> bit {
  bit p = 0;
  for int i in [0:3] {
    p ^= x[i];
  }
  return p;
}

14.1 The circuit you wrote does not always go to the device as-is

We write logical instructions such as H and CX. Real hardware has only a limited set of physical qubits, connections, and native gates. So before sending, we convert to a device-specific instruction sequence that does the same job.

14.2 barrier is not a gate that changes the state

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

14.3 delay makes the wait time explicit

delay[100ns] q[0];

14.4 pulse is a physical signal

14.5 Separate an ideal 50:50 from a dirty result

H|0> is ideally 0/1 at 50:50. Even if it becomes 48:52 on real hardware, it may be fluctuation from the finite 1000 shots. On the other hand, if a Bell circuit continually produces 01 or 10 that should not appear, suspect gate or readout errors.

15.1 An algorithm is the blueprint; a circuit is the instruction list

15.2 An Oracle is a judge, not an answer generator

For example, to build an Oracle where only candidate 10 is correct, you turn the check rule 'true if the input is 10' into a circuit. This does not read out candidate 10 from the start; it checks, by the same rule, whether each input candidate matches the condition. Classical search also needs the same check every time it tries a candidate.

15.3 Distinguish 'optimal' from 'matches the condition'

A standard Grover Oracle judges whether a candidate meets a specified condition. It does not automatically know the shortest route of a VRP. To use it for optimization, you need additional classical steps, such as judging whether a value is below a threshold and updating that threshold.

16.1 Take the candidates as 00, 01, 10, 11

Applying H to two qubits makes all four candidate amplitudes 1/2. Each probability is (1/2)² = 1/4, so measuring gives 25% for every candidate.

16.2 The Oracle flips the sign of 10 only

Let candidate 10 match the condition. After the Oracle the state card is [1/2,1/2,−1/2,1/2]. The probabilities are still all 1/4, so measuring at this point still succeeds only 25% of the time.

16.3 Do the inversion about the mean with numbers

The mean of the four amplitudes is (1/2 + 1/2 − 1/2 + 1/2)/4 = 1/4. Compute each new amplitude as '2 × mean − old amplitude'.

16.4 This is the concrete content of interference

The amplitude calculations for candidates 00, 01, 11 became 0, while candidate 10's became 1. 'Reinforcing the correct answer' means that, through a circuit that adds and subtracts amplitudes, the new amplitudes of non-answers became 0 and the answer's became 1.

16.5 In general, choose the number of iterations

When the number of answers is small relative to the candidate count N, repeat the Oracle and diffusion on the order of about √N times. Repeating too much lowers the answer amplitude again, so running infinitely is not the goal.

17.1 Optimization scores each candidate

Consider a simple MaxCut that splits two people x0, x1 into different groups. xi=0 means group A, 1 means B. If the two differ, score 1; if the same, 0.

17.2 QUBO translates the problem into a 0/1 quadratic

This score can be written C = x0 + x1 − 2·x0·x1. It gives 0 for 00, 1 for 01, 1 for 10, 0 for 11. You can confirm this by substituting the table's four rows.

17.3 Map QUBO to the Ising representation

You can replace a QUBO variable x∈{0,1} with an Ising variable z∈{+1,−1} via x=(1−z)/2. The two-person MaxCut score becomes C=(1−z0·z1)/2. In a quantum circuit, the role of z is replaced by a Z operator, creating a phase change according to each candidate's cost.

17.4 QAOA evaluates the QUBO-derived cost with a circuit

17.5 A two-variable, one-layer OpenQASM skeleton

OPENQASM 3.1;
include "stdgates.inc";
input angle gamma;
input angle beta;
output bit[2] result;
qubit[2] q;
h q;
rzz(2 * gamma) q[0], q[1];
rx(2 * beta) q;
result = measure q;

18.1 Compare the same Bell circuit

18.2 Split errors into three layers

18.3 A fixed debugging procedure

1. 1Write the expected input and the ideal measurement distribution on paper.
2. 2Minimize the circuit and update the state card one gate at a time.
3. 3Check only the syntax with a parser.
4. 4Check the count distribution with an ideal simulator.
5. 5Confirm the bit display order with an X on one side.
6. 6Transpile to the target device and check added gates and depth.
7. 7Compare the real-hardware result with the ideal distribution and isolate noise.

18.4 Capstone projects

• •1/√2 ≈ 0.707, (1/√2)² = 1/2.
• •Probabilities sum to 1. For a one-qubit real amplitude, a²+b²=1.
• •A negative amplitude is not a negative probability. Probability is the amplitude's absolute value squared.
• •H[a,b]=[(a+b)/√2,(a−b)/√2].
• •Grover diffusion, learning calculation: new amplitude = 2 × mean of all amplitudes − old amplitude.

• Can compute X/H/Z with the state card
• Can write the 0-side and 1-side add/subtract in H-Z-H
• Can distinguish the Z basis and X basis as circuits
• Can answer the four CX inputs from the rule, not from memory
• Can follow the 4-component state of the Bell circuit
• Can write OpenQASM declarations, gates, and measurement
• Can distinguish mid-circuit measurement from shots
• Can explain why an Oracle is not an answer generator
• Can fully compute the amplitudes of 2-bit Grover
• Can distinguish QUBO from a QAOA circuit
• Can distinguish a logical circuit from a hardware-targeted circuit

• OpenQASM Live Specification
• OpenQASM 3.1 Language
• OpenQASM Standard Library
• OpenQASM official repository
• IBM Quantum: Introduction to OpenQASM
• IBM Quantum: OpenQASM 3 and Qiskit