Introduction to Quantum Phase Estimation

Introduction

At the heart of nearly every claimed quantum speedup sits one subroutine: Quantum Phase Estimation (QPE). It is the engine inside Shor's algorithm, the driver of quantum chemistry solvers, and the reason quantum computers can extract information that would take classical machines exponentially long.

The idea is deceptively simple. Suppose you have a quantum gate — a unitary operator U — and you know that some quantum state $|\psi\rangle$ is an eigenstate of U. That means $U|\psi\rangle = e^{2\pi i\varphi}|\psi\rangle$ for some phase $\varphi \in [0, 1)$ . The phase $\varphi$ is a real number encoding hidden structure: in Shor's algorithm it encodes the period of a modular function; in chemistry it encodes a molecular ground-state energy.

The catch: $\varphi$ can be any irrational number. Classical intuition says reading it would take infinitely many measurements. QPE defeats this by using a register of n ancilla qubits to encode the binary fraction of $\varphi$ to n bits of precision in a single coherent computation — using only $O(n^{2})$ quantum gates. The trick is the Quantum Fourier Transform (QFT), which converts the phase kickback accumulated in those ancilla qubits into a readable binary number.

QPE was introduced by Alexei Kitaev in 1995 (building on earlier ideas by Deutsch and others) and is today one of the most-studied primitives in quantum computing. It sits in the complexity class BQP — the class of problems a quantum computer can solve efficiently — and is the main ingredient that separates BQP from classical polynomial time for structured problems like factoring.

Try It

Below is a faithful classical simulation of QPE applied to a single-qubit phase gate U with $U|1\rangle = e^{2\pi i\varphi}|1\rangle$ . The eigenstate is $|1\rangle$ and the eigenphase is $\varphi$ .

Choose a target phase $\varphi$ (as a fraction of a full turn) and a number of ancilla qubits n. The algorithm will estimate $\varphi$ to n binary digits of precision.

<p class="hint">QPE applies a phase gate U where U|1⟩ = e<sup>2πiφ</sup>|1⟩ and reads φ as a binary fraction using n ancilla qubits and the quantum Fourier transform. Choose φ and n, then run the algorithm.</p>
<div class="controls">
  <label>Phase φ = <span id="phi-val">0.375</span>
    <input id="phi-slider" type="range" min="0" max="100" value="37" step="1">
  </label>
  <label>Ancilla qubits n = <span id="n-val">3</span>
    <input id="n-slider" type="range" min="1" max="6" value="3" step="1">
  </label>
</div>
<div id="register" class="register"></div>
<div id="result" class="result"></div>
<div class="btns">
  <button id="run" type="button">Run QPE</button>
  <button id="reset" type="button" class="ghost">Reset</button>
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .88rem; color: #444; margin: 0 0 .8rem; line-height: 1.45; }
.controls { display: flex; flex-direction: column; gap: .5rem; margin-bottom: .9rem; }
label { font-size: .9rem; display: flex; align-items: center; gap: .5rem; flex-wrap: wrap; }
input[type=range] { width: 180px; accent-color: #1d3557; }
span { font-weight: 700; color: #1d3557; min-width: 3.5ch; display: inline-block; }
.register { display: flex; gap: 6px; flex-wrap: wrap; margin: .5rem 0; min-height: 58px; align-items: center; }
.qubit { width: 50px; height: 50px; border-radius: 10px; border: 1.5px solid #adb1b8;
         background: #e8eef3; display: flex; flex-direction: column; align-items: center;
         justify-content: center; font-size: .72rem; color: #444; transition: all .3s; }
.qubit .bit { font: 700 18px ui-monospace, monospace; color: #1d3557; }
.qubit.active { background: #1d3557; border-color: #1d3557; }
.qubit.active .bit { color: #fff; }
.qubit.active { color: #9fb2c8; }
.result { background: #f0f4f8; border-radius: 10px; padding: .7rem 1rem; font-size: .92rem;
          line-height: 1.6; min-height: 3.5em; margin: .5rem 0; }
.result .exact { color: #0a7d33; font-weight: 700; }
.result .approx { color: #c97000; font-weight: 700; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
.bar-row { display: flex; align-items: center; gap: 6px; margin-top: .4rem; }
.bar-label { font-size: .75rem; color: #555; min-width: 5ch; text-align: right; }
.bar-bg { flex: 1; height: 10px; background: #dde3e9; border-radius: 5px; overflow: hidden; }
.bar-fill { height: 100%; background: #1d3557; border-radius: 5px; transition: width .4s; }
.bar-fill.peak { background: #e63946; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Quantum Phase Estimation simulation
// U is a 1-qubit phase gate: U|0⟩=|0⟩, U|1⟩=e^(2πiφ)|1⟩
// eigenstate = |1⟩, eigenphase = φ
//
// Algorithm (n ancilla qubits):
//  1. Prepare ancilla in |+⟩^n = H^n |0...0⟩
//  2. Apply controlled-U^(2^k) for k=0..n-1 (phase kickback: ancilla qubit k picks up e^(2πi·2^k·φ))
//  3. Apply inverse QFT to ancilla register
//  4. Measure: result is the n-bit binary fraction closest to φ
//
// Classical simulation: the state after step 2 is
//   (1/√2ⁿ) Σ_{j=0}^{2ⁿ-1} e^(2πi·j·φ) |j⟩
// QFT†: state becomes Σ_k A_k |k⟩ where
//   A_k = (1/2ⁿ) Σ_j e^(2πij(φ - k/2ⁿ))
// |A_k|² = (1/2^(2n)) |Σ_j e^(2πij(φ-k/2ⁿ))|²
// For φ = m/2ⁿ exactly: |A_m|² = 1, all others 0.

const phiSlider = document.getElementById('phi-slider');
const nSlider   = document.getElementById('n-slider');
const phiVal    = document.getElementById('phi-val');
const nVal      = document.getElementById('n-val');
const regDiv    = document.getElementById('register');
const resultDiv = document.getElementById('result');

let phi = 0.375, n = 3;

function updateLabels() {
  phi = parseFloat(phiSlider.value) / 100;
  n   = parseInt(nSlider.value);
  phiVal.textContent = phi.toFixed(3);
  nVal.textContent   = n;
}

phiSlider.addEventListener('input', () => { updateLabels(); renderRegister(); resultDiv.innerHTML = ''; });
nSlider.addEventListener('input',   () => { updateLabels(); renderRegister(); resultDiv.innerHTML = ''; });

function renderRegister() {
  regDiv.innerHTML = '';
  for (let k = 0; k < n; k++) {
    const d = document.createElement('div');
    d.className = 'qubit';
    d.id = 'q' + k;
    d.innerHTML = '<span class="bit">?</span><span>q' + k + '</span>';
    regDiv.appendChild(d);
  }
}

// Compute QPE probability distribution over 2^n outcomes
function qpeDist(phi, n) {
  const N = 1 << n; // 2^n
  const probs = new Float64Array(N);
  for (let k = 0; k < N; k++) {
    // |A_k|^2 = (1/N^2) * |sum_{j=0}^{N-1} e^{2πij(φ - k/N)}|^2
    const delta = phi - k / N;
    if (Math.abs(delta % 1) < 1e-12 || Math.abs((delta % 1) - 1) < 1e-12) {
      probs[k] = (Math.abs(delta) < 1e-9 || Math.abs(delta - Math.round(delta)) < 1e-9) ? 1.0 : 0.0;
    } else {
      // geometric sum: (1 - e^{2πiN·delta}) / (1 - e^{2πi·delta})
      const arg = 2 * Math.PI * delta;
      const argN = arg * N;
      // |sin(Nπδ) / sin(πδ)|^2 / N^2
      const num = Math.sin(N * Math.PI * delta);
      const den = Math.sin(Math.PI * delta);
      probs[k] = (num * num) / (N * N * den * den);
    }
  }
  return probs;
}

function runQPE() {
  updateLabels();
  const N = 1 << n;
  const probs = qpeDist(phi, n);

  // Find peak outcome
  let peakIdx = 0;
  for (let k = 1; k < N; k++) if (probs[k] > probs[peakIdx]) peakIdx = k;

  // Estimated phase = peakIdx / 2^n
  const estPhi = peakIdx / N;
  const error  = Math.abs(phi - estPhi);
  const maxErr = 1 / N;

  // Animate qubits with the binary bits of peakIdx
  for (let k = 0; k < n; k++) {
    const bit = (peakIdx >> (n - 1 - k)) & 1;
    const qDiv = document.getElementById('q' + k);
    if (qDiv) {
      qDiv.querySelector('.bit').textContent = bit;
      qDiv.className = 'qubit' + (bit ? ' active' : '');
    }
  }

  // Build binary fraction string
  let binFrac = '0.';
  for (let k = 0; k < n; k++) binFrac += ((peakIdx >> (n - 1 - k)) & 1);

  const isExact = error < 1e-9;
  const successProb = probs[peakIdx].toFixed(4);
  const cls = isExact ? 'exact' : 'approx';
  const label = isExact ? `Exact!` : `Nearest representable`;

  // Build probability bars (top outcomes)
  const indexed = Array.from(probs).map((p, i) => ({ i, p })).sort((a, b) => b.p - a.p);
  const top = indexed.slice(0, Math.min(4, N));
  let bars = '';
  for (const { i, p } of top) {
    if (p < 0.001) break;
    const pct = (p * 100).toFixed(1);
    const isPeak = i === peakIdx;
    const bf = '0.' + i.toString(2).padStart(n, '0');
    bars += `<div class="bar-row">
      <span class="bar-label">${bf}</span>
      <div class="bar-bg"><div class="bar-fill${isPeak ? ' peak' : ''}" style="width:${pct}%"></div></div>
      <span style="min-width:4ch;font-size:.75rem">${pct}%</span>
    </div>`;
  }

  resultDiv.innerHTML =
    fmt(`QPE reads binary register <b>%binFrac%</b> = <b>%estPhi%</b>&nbsp;
     <span class="%cls%">[%label%]</span><br>
     True φ = %phi% &nbsp;|&nbsp; Error ≤ 1/2<sup>n</sup> = 1/2<sup>%n%</sup> = %maxErr%<br>
     Peak probability: %v%%<br>
     %bars%`, { binFrac: binFrac, estPhi: estPhi.toFixed(6), cls: cls, label: label, phi: phi.toFixed(6), n: n, maxErr: maxErr.toFixed(6), v: (parseFloat(successProb)*100).toFixed(1), bars: bars });

  console.log(fmt(`QPE result: peak=%peakIdx% estPhi=%estPhi% error=%error% prob=%successProb%`, { peakIdx: peakIdx, estPhi: estPhi, error: error, successProb: successProb }));
}

document.getElementById('run').addEventListener('click', runQPE);
document.getElementById('reset').addEventListener('click', () => {
  phiSlider.value = 37; nSlider.value = 3;
  updateLabels(); renderRegister(); resultDiv.innerHTML = '';
});

updateLabels();
renderRegister();

<p class="hint">QPE applies a phase gate U where U|1⟩ = e<sup>2πiφ</sup>|1⟩ and reads φ as a binary fraction using n ancilla qubits and the quantum Fourier transform. Choose φ and n, then run the algorithm.</p>
<div class="controls">
  <label>Phase φ = <span id="phi-val">0.375</span>
    <input id="phi-slider" type="range" min="0" max="100" value="37" step="1">
  </label>
  <label>Ancilla qubits n = <span id="n-val">3</span>
    <input id="n-slider" type="range" min="1" max="6" value="3" step="1">
  </label>
</div>
<div id="register" class="register"></div>
<div id="result" class="result"></div>
<div class="btns">
  <button id="run" type="button">Run QPE</button>
  <button id="reset" type="button" class="ghost">Reset</button>
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .88rem; color: #444; margin: 0 0 .8rem; line-height: 1.45; }
.controls { display: flex; flex-direction: column; gap: .5rem; margin-bottom: .9rem; }
label { font-size: .9rem; display: flex; align-items: center; gap: .5rem; flex-wrap: wrap; }
input[type=range] { width: 180px; accent-color: #1d3557; }
span { font-weight: 700; color: #1d3557; min-width: 3.5ch; display: inline-block; }
.register { display: flex; gap: 6px; flex-wrap: wrap; margin: .5rem 0; min-height: 58px; align-items: center; }
.qubit { width: 50px; height: 50px; border-radius: 10px; border: 1.5px solid #adb1b8;
         background: #e8eef3; display: flex; flex-direction: column; align-items: center;
         justify-content: center; font-size: .72rem; color: #444; transition: all .3s; }
.qubit .bit { font: 700 18px ui-monospace, monospace; color: #1d3557; }
.qubit.active { background: #1d3557; border-color: #1d3557; }
.qubit.active .bit { color: #fff; }
.qubit.active { color: #9fb2c8; }
.result { background: #f0f4f8; border-radius: 10px; padding: .7rem 1rem; font-size: .92rem;
          line-height: 1.6; min-height: 3.5em; margin: .5rem 0; }
.result .exact { color: #0a7d33; font-weight: 700; }
.result .approx { color: #c97000; font-weight: 700; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
.bar-row { display: flex; align-items: center; gap: 6px; margin-top: .4rem; }
.bar-label { font-size: .75rem; color: #555; min-width: 5ch; text-align: right; }
.bar-bg { flex: 1; height: 10px; background: #dde3e9; border-radius: 5px; overflow: hidden; }
.bar-fill { height: 100%; background: #1d3557; border-radius: 5px; transition: width .4s; }
.bar-fill.peak { background: #e63946; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Quantum Phase Estimation simulation
// U is a 1-qubit phase gate: U|0⟩=|0⟩, U|1⟩=e^(2πiφ)|1⟩
// eigenstate = |1⟩, eigenphase = φ
//
// Algorithm (n ancilla qubits):
//  1. Prepare ancilla in |+⟩^n = H^n |0...0⟩
//  2. Apply controlled-U^(2^k) for k=0..n-1 (phase kickback: ancilla qubit k picks up e^(2πi·2^k·φ))
//  3. Apply inverse QFT to ancilla register
//  4. Measure: result is the n-bit binary fraction closest to φ
//
// Classical simulation: the state after step 2 is
//   (1/√2ⁿ) Σ_{j=0}^{2ⁿ-1} e^(2πi·j·φ) |j⟩
// QFT†: state becomes Σ_k A_k |k⟩ where
//   A_k = (1/2ⁿ) Σ_j e^(2πij(φ - k/2ⁿ))
// |A_k|² = (1/2^(2n)) |Σ_j e^(2πij(φ-k/2ⁿ))|²
// For φ = m/2ⁿ exactly: |A_m|² = 1, all others 0.

const phiSlider = document.getElementById('phi-slider');
const nSlider   = document.getElementById('n-slider');
const phiVal    = document.getElementById('phi-val');
const nVal      = document.getElementById('n-val');
const regDiv    = document.getElementById('register');
const resultDiv = document.getElementById('result');

let phi = 0.375, n = 3;

function updateLabels() {
  phi = parseFloat(phiSlider.value) / 100;
  n   = parseInt(nSlider.value);
  phiVal.textContent = phi.toFixed(3);
  nVal.textContent   = n;
}

phiSlider.addEventListener('input', () => { updateLabels(); renderRegister(); resultDiv.innerHTML = ''; });
nSlider.addEventListener('input',   () => { updateLabels(); renderRegister(); resultDiv.innerHTML = ''; });

function renderRegister() {
  regDiv.innerHTML = '';
  for (let k = 0; k < n; k++) {
    const d = document.createElement('div');
    d.className = 'qubit';
    d.id = 'q' + k;
    d.innerHTML = '<span class="bit">?</span><span>q' + k + '</span>';
    regDiv.appendChild(d);
  }
}

// Compute QPE probability distribution over 2^n outcomes
function qpeDist(phi, n) {
  const N = 1 << n; // 2^n
  const probs = new Float64Array(N);
  for (let k = 0; k < N; k++) {
    // |A_k|^2 = (1/N^2) * |sum_{j=0}^{N-1} e^{2πij(φ - k/N)}|^2
    const delta = phi - k / N;
    if (Math.abs(delta % 1) < 1e-12 || Math.abs((delta % 1) - 1) < 1e-12) {
      probs[k] = (Math.abs(delta) < 1e-9 || Math.abs(delta - Math.round(delta)) < 1e-9) ? 1.0 : 0.0;
    } else {
      // geometric sum: (1 - e^{2πiN·delta}) / (1 - e^{2πi·delta})
      const arg = 2 * Math.PI * delta;
      const argN = arg * N;
      // |sin(Nπδ) / sin(πδ)|^2 / N^2
      const num = Math.sin(N * Math.PI * delta);
      const den = Math.sin(Math.PI * delta);
      probs[k] = (num * num) / (N * N * den * den);
    }
  }
  return probs;
}

function runQPE() {
  updateLabels();
  const N = 1 << n;
  const probs = qpeDist(phi, n);

  // Find peak outcome
  let peakIdx = 0;
  for (let k = 1; k < N; k++) if (probs[k] > probs[peakIdx]) peakIdx = k;

  // Estimated phase = peakIdx / 2^n
  const estPhi = peakIdx / N;
  const error  = Math.abs(phi - estPhi);
  const maxErr = 1 / N;

  // Animate qubits with the binary bits of peakIdx
  for (let k = 0; k < n; k++) {
    const bit = (peakIdx >> (n - 1 - k)) & 1;
    const qDiv = document.getElementById('q' + k);
    if (qDiv) {
      qDiv.querySelector('.bit').textContent = bit;
      qDiv.className = 'qubit' + (bit ? ' active' : '');
    }
  }

  // Build binary fraction string
  let binFrac = '0.';
  for (let k = 0; k < n; k++) binFrac += ((peakIdx >> (n - 1 - k)) & 1);

  const isExact = error < 1e-9;
  const successProb = probs[peakIdx].toFixed(4);
  const cls = isExact ? 'exact' : 'approx';
  const label = isExact ? `Exact!` : `Nearest representable`;

  // Build probability bars (top outcomes)
  const indexed = Array.from(probs).map((p, i) => ({ i, p })).sort((a, b) => b.p - a.p);
  const top = indexed.slice(0, Math.min(4, N));
  let bars = '';
  for (const { i, p } of top) {
    if (p < 0.001) break;
    const pct = (p * 100).toFixed(1);
    const isPeak = i === peakIdx;
    const bf = '0.' + i.toString(2).padStart(n, '0');
    bars += `<div class="bar-row">
      <span class="bar-label">${bf}</span>
      <div class="bar-bg"><div class="bar-fill${isPeak ? ' peak' : ''}" style="width:${pct}%"></div></div>
      <span style="min-width:4ch;font-size:.75rem">${pct}%</span>
    </div>`;
  }

  resultDiv.innerHTML =
    fmt(`QPE reads binary register <b>%binFrac%</b> = <b>%estPhi%</b>&nbsp;
     <span class="%cls%">[%label%]</span><br>
     True φ = %phi% &nbsp;|&nbsp; Error ≤ 1/2<sup>n</sup> = 1/2<sup>%n%</sup> = %maxErr%<br>
     Peak probability: %v%%<br>
     %bars%`, { binFrac: binFrac, estPhi: estPhi.toFixed(6), cls: cls, label: label, phi: phi.toFixed(6), n: n, maxErr: maxErr.toFixed(6), v: (parseFloat(successProb)*100).toFixed(1), bars: bars });

  console.log(fmt(`QPE result: peak=%peakIdx% estPhi=%estPhi% error=%error% prob=%successProb%`, { peakIdx: peakIdx, estPhi: estPhi, error: error, successProb: successProb }));
}

document.getElementById('run').addEventListener('click', runQPE);
document.getElementById('reset').addEventListener('click', () => {
  phiSlider.value = 37; nSlider.value = 3;
  updateLabels(); renderRegister(); resultDiv.innerHTML = '';
});

updateLabels();
renderRegister();

Result

Console

Notice how the estimate snaps to the exact value whenever $\varphi$ is an exact n-bit binary fraction (like 0.375 = 3/8 with n = 3). For other phases the algorithm returns the nearest representable fraction. More ancilla qubits mean finer resolution — the error halves with each extra qubit, giving exponential precision growth with register size.

The Real Complexity

What does QPE actually cost, and why is the speedup real?

The quantum resource: n ancilla qubits and $O(n)$ applications of controlled-U (each application doubling the power: U, $U^{2}$ , $U^{4}$ , …, $U^{2^{n-1}}$ )). The QFT itself takes $O(n^{2})$ gates.
Classical lower bound: reading n bits of an arbitrary phase classically requires n independent experiments, each with access to U — the same asymptotic count. The quantum advantage is not in the number of calls but in the coherence: QPE runs all queries in superposition and reads out the full binary fraction in a single measurement, whereas classical repetition collapses each bit separately.
For structured problems the gap is exponential: in Shor's algorithm, the unitary is modular exponentiation and the phase encodes a period. Classical period-finding needs sub-exponential time (best known: number field sieve), but QPE + QFT finds the period in $O(n^{3})$ quantum gates for an n-bit number — that is the source of the exponential separation.
Complexity class: QPE is in BQP (bounded-error quantum polynomial time). Whether BQP strictly contains BPP (classical probabilistic polynomial time) is an open question, but for factoring — where no classical polynomial-time algorithm is known — QPE gives strong evidence that it does.
Error and precision: with n ancilla qubits, QPE returns $\varphi$ to within $1/2^n$ with probability at least $4/\pi^2 \approx 0.405$ . Repeating $O(1/\varepsilon)$ times and taking the majority boosts success probability arbitrarily close to 1.

QPE is not just an academic curiosity — it is the reason Shor's algorithm breaks RSA, and why quantum computers are expected to simulate quantum chemistry (via quantum phase estimation on molecular Hamiltonians) in polynomial time.

Where It Matters

QPE is not a single algorithm — it is a primitive that unlocks an entire family of quantum speedups:

Cryptography (Shor's algorithm): QPE on the order-finding unitary recovers the period of $a^{x} \bmod N$ , letting Shor's algorithm factor large integers in polynomial quantum time. This directly threatens RSA and ECC encryption. (See Shor's algorithm for the full story.)
Quantum chemistry (energy estimation): The ground-state energy of a molecule is an eigenvalue of its Hamiltonian. QPE applied to the time-evolution operator $e^{-iHt}$ extracts the energy to chemical accuracy in polynomial quantum time — a task believed to require exponential classical resources for large molecules.
Quantum linear algebra (HHL algorithm): The Harrow–Hassidim–Lloyd (HHL) algorithm uses QPE to estimate eigenvalues of a matrix, then performs a quantum matrix inversion. This gives an exponential speedup for solving sparse linear systems — with important caveats about input/output.
Quantum simulation: Simulating the dynamics of quantum systems (condensed matter, particle physics) reduces to repeated applications of a unitary; QPE measures the resulting phases to extract physically meaningful quantities.
Quantum machine learning: Variational quantum eigensolvers (VQEs) approximate QPE with shallower circuits, trading precision for near-term hardware compatibility.

Almost any quantum speedup you read about traces back, directly or indirectly, to phase estimation. Master QPE and you have the skeleton key to quantum computing's most powerful results.

Conclusion

Quantum phase estimation is, in a sense, the punchline of quantum computing: the moment where superposition and interference stop being philosophical curiosities and become a computational resource. By running all queries to U in superposition and applying the quantum Fourier transform, QPE reads n bits of a hidden phase using only $O(n^{2})$ gates — exponentially cheaper than any classical strategy for the same structured problems.

That single idea — encode, interfere, measure — is why Shor's algorithm factors numbers in polynomial time, why quantum computers can simulate molecules classical hardware cannot, and why the gap between BQP and BPP might be the most practically important open question in theoretical computer science today.

The next time you hear about a quantum speedup, look for the phase. Almost certainly, QPE is what is doing the heavy lifting.

Comments

Loading comments...

https://www.kipuhub.com/en/article/quantum-phase-estimation/Content licensed under CC BY-NC 4.0.

Cookies & privacy

Quantum Phase Estimation

How a quantum computer reads a phase to exponential precision