Cheat sheet

Lookup reference. Identities that hold only up to a global phase are marked as such. c = cos(θ/2), s = sin(θ/2), w = 1/sqrt(2) ≈ 0.7071.

1. Single-qubit gates

Useful specialisations: P(pi)=Z, P(pi/2)=S, P(pi/4)=T, U(pi/2,0,pi)=H, U(pi,0,pi)=X. Rx(pi)=X, Ry(pi)=Y, Rz(pi)=Z each up to the global phase -i.

2. Multi-qubit gates

3. Identities and rewrite rules

"Up to phase" means the two operators differ by a scalar of modulus 1, which is unobservable unless the block sits inside a controlled operation — then the phase becomes relative and matters.

Pauli algebra

Conjugations (the golf ammunition)

Phase-gate ladder

Two-qubit rewrites

Pauli propagation through CNOT (conjugation, control c → target t)

Three-qubit rewrites

4. Common states

Written in circuit order |q0 q1> — leftmost symbol is qubit 0. Qiskit counts strings print the reverse (§6).

Bell states

Reading the correlations: <ZZ> = +1 means both Z-basis measurements always agree (outcomes 00/11); −1 means they always disagree (01/10). Φ⁺ is the only one with <ZZ>=<XX>=+1; Ψ⁻ is the only one anti-correlated in all three bases, which identifies it instantly from a transcript.

Multi-qubit

5. Measuring in a rotated basis

Hardware only measures in the Z basis. To measure observable M, apply the unitary that maps M's eigenbasis onto the Z basis, then measure. Outcome 0 ⇒ eigenvalue +1, outcome 1 ⇒ −1.

BB84 basis labels: bit 0 = rectilinear/Z (|0>,|1>), bit 1 = diagonal/X (|+>,|−>). Prepare X-basis with h after the optional x; measure X-basis with h before measure.

6. Qiskit API (2.5.0)

Build

from qiskit import QuantumCircuit, transpile
qc = QuantumCircuit(3, 3)          # 3 qubits, 3 classical bits
qc.h(0); qc.cx(0, 1); qc.ccx(0, 1, 2)
qc.rz(0.3, 1); qc.barrier()
qc.measure([0, 1, 2], [0, 1, 2])   # or qc.measure_all() (adds its own creg)
qc.reset(0)
qc.initialize([0.6, 0.8], 0)       # explicit amplitudes
print(qc.draw())                   # text diagram
qc.depth(); qc.count_ops(); qc.size()
qc2 = qc.inverse(); qc3 = qc.compose(other); qc.reverse_bits()
g = other.to_gate(); qc.append(g.control(2), [0, 1, 2, 3])

Mid-circuit conditionals

# c_if is REMOVED in Qiskit 2.x — use the context manager:
qc.measure(0, 0)
with qc.if_test((qc.clbits[0], 1)):
    qc.x(1)

Simulate

from qiskit_aer import AerSimulator
sim = AerSimulator()
res = sim.run(transpile(qc, sim), shots=1024).result()
counts = res.get_counts()          # {'00': 504, '11': 520}

# or the reference primitive (no Aer needed):
from qiskit.primitives import StatevectorSampler
r = StatevectorSampler().run([qc], shots=1024).result()
counts = r[0].data.c.get_counts()  # .c = name of the classical register

quantum_info (exact, no shots — use this whenever possible)

from qiskit.quantum_info import (Statevector, Operator, DensityMatrix,
    partial_trace, entropy, purity, state_fidelity, Pauli, SparsePauliOp)

sv = Statevector(qc_without_measurements)
sv.data                     # numpy amplitude array
sv.probabilities_dict()     # {'00': 0.5, '11': 0.5}
sv.expectation_value(Pauli('XX'))
Statevector.from_label('+')                 # also '0','1','-','r'(=|i>),'l'
state_fidelity(sv_a, sv_b)

U = Operator(qc).data       # unitary as numpy array
Operator(qc_a).equiv(Operator(qc_b))        # True if equal UP TO GLOBAL PHASE
Operator(qc_a) == Operator(qc_b)            # exact, phase-sensitive

rho = partial_trace(sv, [1])                # trace out qubit 1
entropy(rho)                # 1.0 for a Bell state half; 0.0 if separable
purity(rho)                 # 1.0 pure, 0.5 maximally mixed (1 qubit)

Transpile / basis change

t = transpile(qc, basis_gates=['u', 'cx'], optimization_level=3)
t = transpile(qc, basis_gates=['h','t','tdg','cx'])
t = transpile(qc, coupling_map=[[0,1],[1,2]], optimization_level=3)
t.count_ops(); t.depth()
qc.decompose()              # one level of unrolling, no optimisation

QASM in / out

from qiskit import qasm2, qasm3
qc = qasm2.loads(src); qc = qasm2.load('c.qasm')
src = qasm2.dumps(qc)          # fails on non-register-equality conditionals
src = qasm3.dumps(qc)
# qasm3.loads/load needs an extra package: pip install qiskit_qasm3_import

Counts handling

max(counts, key=counts.get)                     # most likely bitstring
sorted(counts.items(), key=lambda kv: -kv[1])[:5]
sum(v for k, v in counts.items() if k[-1] == '1') / shots   # P(qubit0 = 1)
int(bitstring[::-1], 2)                         # reverse then parse to int

7. OpenQASM 2 vs OpenQASM 3

Minimal complete OpenQASM 2 program (parses in Qiskit 2.5.0)

OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
gate mygate a, b { h a; cx a, b; }
h q[0];
cx q[0], q[1];
rz(pi/4) q[1];
mygate q[0], q[1];
measure q -> c;
if (c==3) x q[0];

Minimal complete OpenQASM 3 program

OPENQASM 3.0;
include "stdgates.inc";
qubit[2] q;
bit[2] c;
gate mygate a, b { h a; cx a, b; }
h q[0];
cx q[0], q[1];
rz(pi/4) q[1];
mygate q[0], q[1];
c[0] = measure q[0];
c[1] = measure q[1];
if (c[0]) { x q[1]; }        // register form: if (c == 3) { ... }

8. Classical crypto glue

The quantum part usually ends with a bitstring. Everything after that is normal CTF work.

Bits ↔ bytes

bits = [1,0,1,0,0,0,0,1]                       # or "10100001"
s    = "".join(map(str, bits))
data = int(s, 2).to_bytes(len(s)//8, 'big')    # b'\xa1'
# per-byte, avoids leading-zero loss:
data = bytes(int(s[i:i+8], 2) for i in range(0, len(s), 8))
# back:
s = "".join(f"{b:08b}" for b in data)
# MSB-first vs LSB-first: if the flag is garbage, try s[::-1] and per-byte reversal

XOR / encodings

xor = bytes(a ^ b for a, b in zip(ct, key))                  # equal length
xor = bytes(c ^ key[i % len(key)] for i, c in enumerate(ct)) # repeating key
import base64, binascii
base64.b64decode("aGk=")        # b'hi'
bytes.fromhex("6869")           # b'hi'
binascii.hexlify(b'hi')         # b'6869'
data.decode('utf-8', 'replace')

AES

from Crypto.Cipher import AES              # pycryptodome
from Crypto.Util.Padding import unpad
AES.new(key, AES.MODE_ECB).decrypt(ct)                 # no IV, blocks independent
unpad(AES.new(key, AES.MODE_CBC, iv).decrypt(ct), 16)  # IV = first 16 bytes of ct, usually
AES.new(key, AES.MODE_CTR, nonce=n).decrypt(ct)        # stream, no padding
AES.new(key, AES.MODE_GCM, nonce=n).decrypt(ct)        # +16-byte tag at the end

The standard QKD challenge chain

1. Parse the transcript          -> Alice bits, Alice bases, Bob bases, Bob results
2. Sift: keep positions where    -> alice_bases[i] == bob_bases[i]     (~50% survive)
3. Drop the disclosed sample     -> the bits used for the QBER estimate
4. Key bits -> bytes             -> 128 sifted bits = AES-128 key (256 -> AES-256)
5. Decrypt                       -> AES-CBC/ECB with that key, IV often prepended
6. Flag                          -> if it decodes to noise, try: bit order reversed,
                                    bases inverted (0=X not Z), key derived via
                                    SHA-256(bitstring) instead of raw packing

Also try hashlib.sha256(bits_str.encode()).digest() and hashlib.sha256(key_bytes).digest() as key derivations — both are common.

9. Constants

10. CTF conventions

Other habits worth keeping: each category's intro challenge unlocks the rest, so clear all intros first; save every transcript and circuit file before editing; when a numeric answer is requested, check whether the scoreboard wants it raw, rounded, or wrapped in the flag format.