Issue Zero · The Quantum Observer · First Dispatch

There is a moment — every engineer who has touched a quantum circuit knows it — when the abstraction collapses. When the tidy textbook equation you have been moving around like a chess piece suddenly becomes a physical thing: a microwave pulse fired at a superconducting qubit at 15 millikelvin, precise to the nanosecond, fragile to the femtojoule. The moment you feel that reality land is the moment you become a quantum engineer.

This publication exists to manufacture that moment, systematically, at scale.

Welcome to Issue Zero.

I. What “Full-Stack Quantum Engineering” Actually Means¶

The phrase gets misused constantly. Let’s fix that right now.

Classical “full-stack” means frontend to backend to database — the complete vertical of an application. Quantum full-stack is structurally identical, but the layers are different:

A full-stack quantum engineer can move fluently across every row. They can derive the gate decomposition of a Toffoli from scratch and submit a job to a real backend and interpret the noise-mitigation output. They do not live at one layer and accept the others as black boxes.

This is what we mean. And it is what every article in this publication is designed to build.

II. Why Production-Grade Thinking Matters Now¶

The quantum computing landscape has a dirty secret: most educational content stops at the simulator. You learn to write $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$, you implement Grover’s search on a noise-free Aer backend, and then you are left to discover on your own that real hardware does not behave like the textbook.

Here is what changes when you cross from simulator to production:

1. Coherence time is a hard constraint, not a parameter. On an IBM Eagle processor, T₂ (dephasing time) for a superconducting qubit runs between 50–300 μs. Your circuit must complete before the qubit forgets what it is doing. This forces circuit depth minimization as a first-class engineering concern — not an optimisation pass.

2. Gate fidelity is probabilistic, not binary. A two-qubit CNOT gate on current hardware achieves roughly 99–99.5% fidelity per operation. Run 100 CNOT gates in series, and your state fidelity drops to approximately $(0.995)^{100} \approx 0.607$. Over 200 gates: 0.37. The circuit that looks elegant on paper becomes noise-dominated before it completes.

3. Connectivity is a topology constraint. IBMQ’s heavy-hex topology means not every qubit pair can directly perform a two-qubit gate. Your algorithm’s logical connectivity must be mapped to the hardware graph, inserting SWAP gates where direct connection does not exist. Each SWAP costs three CNOT gates. Ignoring topology at circuit design time is one of the most expensive mistakes in quantum engineering.

4. Measurement is not free. Readout error — the probability of measuring $|0\rangle$ when the qubit is actually in $|1\rangle$, or vice versa — runs between 1–5% per qubit on near-term hardware. For algorithms whose output is a single bitstring measurement, this is catastrophic without mitigation.

Production-grade thinking means designing for these constraints from the first line of code — not discovering them in post-processing. Every algorithm in the Quantum Engineering Codex is presented with its hardware reality already baked into the design.

III. From Axiom to Deployed Circuit — The Bernstein-Vazirani Algorithm¶

Let us make this concrete. We will take one algorithm from its mathematical foundation to a real Qiskit circuit, submitted to a simulator. This is the Bernstein-Vazirani problem — less famous than Grover’s, but pedagogically perfect for demonstrating quantum advantage from first principles.

3.1 The Problem¶

Given: An oracle (black box) $f: \{0,1\}^n \rightarrow \{0,1\}$ that computes:

$$f(\mathbf{x}) = \mathbf{s} \cdot \mathbf{x} \pmod{2}$$

where $\mathbf{s} \in \{0,1\}^n$ is a hidden secret string and $\cdot$ denotes the bitwise inner product.

Goal: Find $\mathbf{s}$.

Classical complexity: $n$ oracle queries are required — one per bit of the secret string.

Quantum complexity: $1$ oracle query. Always. Regardless of $n$.

This is an exponential separation. Not polynomial. The quantum algorithm solves in one step what requires $n$ steps classically. And unlike Grover’s quadratic speedup, this one is provably optimal with no hidden constants.

3.2 The Mathematical Foundation¶

The key is the Hadamard transform. A single Hadamard gate maps:

$$H|0\rangle = \frac{|0\rangle + |1\rangle}{\sqrt{2}}, \qquad H|1\rangle = \frac{|0\rangle - |1\rangle}{\sqrt{2}}$$

Applying $H^{\otimes n}$ to the all-zeros state creates a uniform superposition over all $n$-bit strings:

$$H^{\otimes n}|0\rangle^{\otimes n} = \frac{1}{\sqrt{2^n}} \sum_{\mathbf{x} \in \{0,1\}^n} |\mathbf{x}\rangle$$

The phase kickback trick: If we encode the oracle as a phase oracle $U_f$ such that:

$$U_f|\mathbf{x}\rangle = (-1)^{f(\mathbf{x})}|\mathbf{x}\rangle = (-1)^{\mathbf{s} \cdot \mathbf{x}}|\mathbf{x}\rangle$$

Then applying $H^{\otimes n}$ again after the oracle:

$$H^{\otimes n} U_f H^{\otimes n} |0\rangle^{\otimes n} = H^{\otimes n} \left( \frac{1}{\sqrt{2^n}} \sum_{\mathbf{x}} (-1)^{\mathbf{s} \cdot \mathbf{x}} |\mathbf{x}\rangle \right) = |\mathbf{s}\rangle$$

The final state is exactly $|\mathbf{s}\rangle$. Measuring in the computational basis returns the full secret string with probability 1. One query. One measurement. Done.

3.3 Circuit Structure¶

The Bernstein-Vazirani circuit is a sequence of four steps:

       ┌───┐ ┌──────┐ ┌───┐ ┌─┐
q₀: ───┤ H ├─┤      ├─┤ H ├─┤M├
       ├───┤ │      │ ├───┤ └─┘
q₁: ───┤ H ├─┤  Uf  ├─┤ H ├─┤M├
       ├───┤ │      │ ├───┤ └─┘
q₂: ───┤ H ├─┤      ├─┤ H ├─┤M├
       └───┘ └──────┘ └───┘

Step 1: Hadamard on all input qubits → uniform superposition Step 2: Phase oracle $U_f$ encoding secret $\mathbf{s}$ Step 3: Hadamard on all qubits again → interference collapses to $|\mathbf{s}\rangle$ Step 4: Measurement → read $\mathbf{s}$ directly

The phase oracle for $f(\mathbf{x}) = \mathbf{s} \cdot \mathbf{x}$ is implemented as a CZ gate (controlled-Z) for each bit position $i$ where $s_i = 1$. The CZ applies a phase of $-1$ when both the control qubit $q_i$ and an ancilla qubit in state $|{-}\rangle = \frac{|0\rangle - |1\rangle}{\sqrt{2}}$ are $|1\rangle$ — but since we are working with the phase oracle formulation directly, we simply apply $Z$ to each qubit $q_i$ where $s_i = 1$.

3.4 Qiskit Implementation¶

Let’s implement this for secret string $\mathbf{s} = \mathtt{101101}$ ($n = 6$ qubits):

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit_aer import AerSimulator

# Secret string s = '101101' (we want to recover this in one query)
secret = '101101'
n = len(secret)

q = QuantumRegister(n, 'q')
c = ClassicalRegister(n, 'c')
qc = QuantumCircuit(q, c)

# Step 1: Hadamard on all input qubits
qc.h(range(n))
qc.barrier()

# Step 2: Phase oracle — apply Z to qubit i where secret[i] == '1'
# Note: secret string is read right-to-left (qubit 0 = rightmost bit)
for i, bit in enumerate(reversed(secret)):
    if bit == '1':
        qc.z(i)

qc.barrier()

# Step 3: Hadamard again — interference collapses to |s⟩
qc.h(range(n))
qc.barrier()

# Step 4: Measure
qc.measure(q, c)

# Execute on noise-free Aer simulator
simulator = AerSimulator()
result = simulator.run(qc, shots=1024).result()
counts = result.get_counts()

# Expected: {'101101': 1024} — perfect recovery every time
print(f"Recovered secret: {max(counts, key=counts.get)}")
print(f"Counts: {counts}")

Output:

Recovered secret: 101101
Counts: {'101101': 1024}

The secret string is recovered with 100% probability in a single oracle call, across all 1024 shots. No probability, no amplification loop, no post-processing. One query. The answer.

3.5 What Changes on Real Hardware¶

When we submit this circuit to a real backend (e.g., ibm_brisbane), several things happen:

Transpilation: The 6-qubit circuit is mapped to the hardware’s connectivity graph. Z gates do not require connectivity, but measurement operations and Hadamard gates must be decomposed into the native gate set (typically: $\{CX, ID, RZ, SX, X\}$). The transpiler inserts SX-RZ decompositions of H, adding circuit depth.

Readout error: With ~1.5% per-qubit readout error, measuring 6 qubits correctly in one shot has probability roughly $(0.985)^6 \approx 0.914$. Approximately 1 in 11 shots will return the wrong answer due to readout noise alone, even though the quantum computation itself is perfect.

Noise mitigation: Apply M3 readout error mitigation (from mthree package) using a calibration matrix $A$ such that $|\text{ideal}\rangle = A^{-1}|\text{noisy}\rangle$. Post-mitigation accuracy returns to >99% on current hardware for this circuit depth.

This is the gap. This is why production-grade thinking matters. The algorithm is provably correct. The execution environment is not. Understanding the full stack means designing for both.

IV. The Standard We Hold Ourselves To¶

Every piece in The Quantum Observer will be written against a single test:

Could a rigorous mind reconstruct the full understanding from scratch using only what is written here? From the axiom to the equation, from the equation to the circuit, from the circuit to the deployed result?

If the answer is no, we do not publish.

This is not about difficulty. Some of our articles will be accessible to engineers who have never touched a quantum circuit. Others will assume familiarity with Hilbert spaces and density matrices. But at every level, the commitment is the same: no gap left unbridged. No “it can be shown that…”. No “as you can verify…”. We show. We verify. We run.

V. Join the Armada¶

The Quantum Observer is not a news site. It is not a course. It is not a repository of tutorials.

It is a publication — in the original sense of the word. A place where rigorous ideas are brought before the public in their full form, without simplification, without apology, and without a paywall between the idea and the reader.

We publish because the gap between quantum physics and quantum engineering is real, costly, and largely artificial — maintained by institutions that benefit from keeping knowledge fragmented and credentialed. We do not benefit from that. Our readers do not benefit from that.

So we publish everything. Every derivation. Every circuit. Every noise profile. Every benchmark. And we make it free, forever, to anyone who shows up with a serious question.

If that is the publication you have been waiting for: you are already here.

Subscribe to The Quantum Briefing and receive every new dispatch directly in your inbox. Download the Quantum Engineering Codex and carry the full reference with you. And if you find something wrong — a derivation with an error, a circuit that doesn’t compile, a benchmark we misread — write to us. We correct publicly, with attribution, without defensiveness.

The armada is not a metaphor. It is every engineer and physicist who decided that knowing things properly — all the way down to the axiom, all the way up to the deployed circuit — is not optional.

It’s just how we work.

Mejbah Ahammad Founding Editor, The Quantum Observer Issue Zero — The Beginning