# Quantum computing
## Microsim
### Live player
<div class="microsim-player">
<iframe src="https://editor.p5js.org/sciencenibber/full/REj7QBkj4" width="100%" height="620" frameborder="0" sandbox="allow-scripts allow-same-origin"></iframe>
</div>
<div class="microsim-fallback">
<img src="Microsims/thumbs/Quantum_computing.png" alt="Quantum_computing microsim poster" style="width:100%;border:1px solid #4445;border-radius:6px;">
<p><em>Live microsim (desktop) · <a href="https://editor.p5js.org/sciencenibber/sketches/REj7QBkj4">open sketch in the p5.js editor</a></em></p>
</div>
**Editor URL:** https://editor.p5js.org/sciencenibber/sketches/REj7QBkj4
**Description (100 words):**
A log-log family of surface-code performance curves, one per code distance d in {3, 5, 7, 11, 17, 25}. The reader drags three sliders — physical error per gate p, code distance d, and physical-qubit budget N_phys — and watches the active (yellow) curve, the chosen point's logical error rate, and a right-side budget panel update in real time. A dashed magenta line marks the surface-code threshold at p_th = 0.01. The panel tiles out N_logical = N_phys / (2 d^2) logical qubits and reports the circuit success probability over 10,000 cycles. Below threshold each curve plunges exponentially; above it, all curves climb past 1.
```js
// =====================================================================
// Quantum_computing.js -- Wikitube microsim
// Article: Quantum computing en.wikitube.io/wiki/Quantum_computing
// Room: Helium Pattern: D (parametric performance curves)
// ---------------------------------------------------------------------
// Idea: an interactive surface-code performance plot. The reader drags
// three sliders -- physical error per gate (p), code distance (d), and
// physical-qubit budget (N_phys) -- and watches the family of logical
// error curves, the resulting logical-qubit count, and the success
// probability of a target circuit update live.
//
// The surface code is the dominant error-correcting code on every
// superconducting and silicon-spin quantum platform today (IBM, Google,
// Rigetti, Intel). It tiles physical qubits into a 2D lattice and
// detects errors by repeatedly measuring four-body stabilizers. Below
// the threshold p_th ~ 0.01 errors-per-gate, the logical error rate
// drops *exponentially* in the code distance d:
//
// P_L = A * (p / p_th)^((d + 1)/2)
//
// with A ~ 0.03 fitted from Fowler et al. (2012). Above p_th the code
// *amplifies* errors instead of suppressing them -- the curve crosses
// the dashed threshold line and bends the wrong way. That crossing is
// the single most important boundary in fault-tolerant quantum
// computing, and is the visual centerpiece of this microsim.
//
// Each logical qubit costs ~2*d^2 physical qubits (data + measurement
// ancillas + routing overhead, simplified from the full count). Given
// N_phys physical qubits, the reader gets
//
// N_log = floor(N_phys / (2 * d^2))
//
// logical qubits, which the right-side panel reports as a stack of
// filled tiles. Bigger d means lower P_L but fewer N_log -- the
// fundamental architectural tradeoff.
//
// Circuit success probability at the logical level is then
//
// P_success = (1 - P_L)^(N_log * D_circuit)
//
// with D_circuit a fixed reference depth (10000 cycles), a stand-in
// for a Shor-factoring or quantum-chemistry workload. The bottom
// bar visualizes P_success as a horizontal fill.
//
// Helium connection (room context): every superconducting transmon
// and silicon-spin quantum platform on Earth lives inside a He-3/He-4
// dilution refrigerator at 10-20 mK to suppress thermal occupation of
// the microwave-frequency qubit transitions. The microsim itself is
// agnostic to platform -- the surface-code curves apply to any qubit
// technology that hits the same physical error rate.
//
// Visual layout (720 x 520 canvas):
// * top-left: HUD title + en.wikitube.io/wiki/Quantum_computing
// * top-right: short hint ("drag sliders; threshold = vertical line")
// * center-left: log-log plot, x = p (1e-4 to 1e-1), y = P_L (1e-15 to 1)
// one curve per code distance d in {3, 5, 7, 11, 17, 25};
// the user's d is drawn thicker in the TRAJ accent color
// * vertical TRAJ line at current p; intersection dots on each curve
// * dashed magenta threshold line at p = p_th = 0.01
// * right panel: logical-qubit tile stack + success-prob bar + readouts
// * bottom: three sliders (p, d, N_phys) with labels
// * bottom-right corner: canonical equation in ASCII
//
// Conventions (Wikitube Betterfire Standard v0):
// * single ARTICLE constant at the top, single quotes
// * p5.disableFriendlyErrors = true to keep the editor console clean
// * non-ASCII (Greek, dots, arrows) lives in COMMENTS ONLY; every
// text() string literal is ASCII (the editor preview pipeline
// mangles non-ASCII in strings)
// * Energy-room palette (P5_JS_EDITOR section 4, line 165): dark BG,
// HOT/COLD tones, STRUCT grey, TRAJ accent yellow
// * sliders all carry explicit .position(x, y).size(w)
// =====================================================================
const ARTICLE = 'Quantum_computing';
const TITLE = ARTICLE.replace(/_/g, ' ');
p5.disableFriendlyErrors = true;
// ----- Energy room palette (P5_JS_EDITOR section 4, line 165) --------
const BG = 18;
const FG = 240;
const DIM = [240, 240, 240, 140];
const HOT = [220, 110, 60]; // warm: above-threshold curves
const COLD = [60, 130, 220]; // cool: below-threshold curves
const STRUCT = [120, 130, 150]; // structural grey
const TRAJ = [240, 220, 80]; // user's active curve / marker
const GAUGE = [120, 220, 140]; // success-prob bar
const ACCENT = [200, 100, 220]; // threshold line magenta
const SCRATCH = [120, 120, 120, 70];
// ----- Surface-code performance constants ----------------------------
const P_TH = 0.01; // surface-code threshold (errors per gate)
const A_FIT = 0.03; // prefactor in P_L = A * (p/p_th)^((d+1)/2)
const D_CIRCUIT = 10000; // target circuit depth in logical cycles
const D_LIST = [3, 5, 7, 11, 17, 25]; // distances drawn as the curve family
// ----- Axis bounds (log-log) -----------------------------------------
const P_MIN = 1e-4;
const P_MAX = 1e-1;
const PL_MIN = 1e-15;
const PL_MAX = 1.0;
// ----- Layout regions ------------------------------------------------
const PLOT_X = 60;
const PLOT_Y = 50;
const PLOT_W = 430;
const PLOT_H = 320;
const PANEL_X = 510;
const PANEL_Y = 50;
const PANEL_W = 200;
const PANEL_H = 320;
// ----- Sliders -------------------------------------------------------
let pSlider, dSlider, nSlider;
function setup() {
createCanvas(720, 520);
pixelDensity(2);
textFont('system-ui');
// p slider drives log10(p); slider value is mantissa exponent * 100
// for slider resolution. Map back with pow(10, val/100).
pSlider = createSlider(-400, -100, -250, 1)
.position(60, 410)
.size(220);
// code distance d -- index into D_LIST so the slider snaps to allowed values
dSlider = createSlider(0, D_LIST.length - 1, 2, 1)
.position(60, 445)
.size(220);
// physical qubit budget N_phys, log scale 100 - 1,000,000
nSlider = createSlider(2, 6, 4, 0.05)
.position(60, 480)
.size(220);
}
function draw() {
background(BG);
// ---- read slider state into named locals ----
const p = pow(10, pSlider.value() / 100); // physical error per gate
const d = D_LIST[dSlider.value()]; // code distance
const nPhys = floor(pow(10, nSlider.value())); // physical qubit budget
// ---- derived quantities ----
const PL = logicalErrorRate(p, d);
const nLog = floor(nPhys / (2 * d * d));
// P_success guarded against PL == 0 (deep below threshold)
let pSuccess = 0;
if (nLog > 0) {
const totalCycles = nLog * D_CIRCUIT;
pSuccess = exp(totalCycles * log(max(1 - PL, 1e-300)));
}
drawPlot(p, d, PL);
drawPanel(d, nLog, nPhys, PL, pSuccess);
drawSliderLabels(p, d, nPhys);
drawEquation();
drawHUD();
}
// ---------------------------------------------------------------------
// Surface-code logical error per cycle.
// P_L = A * (p / p_th)^((d+1)/2) for p <= p_th
// Above threshold the same expression continues smoothly but the
// exponent (d+1)/2 makes P_L explode and saturate above 1, where it
// is clamped for plotting purposes.
// ---------------------------------------------------------------------
function logicalErrorRate(p, d) {
const exponent = (d + 1) / 2;
const ratio = p / P_TH;
return A_FIT * pow(ratio, exponent);
}
// ---------------------------------------------------------------------
// Map between (p, P_L) in physical units and canvas pixels.
// Both axes are base-10 log.
// ---------------------------------------------------------------------
function xOfP(p) {
const lp = log(p) / log(10);
const lo = log(P_MIN)/ log(10);
const hi = log(P_MAX)/ log(10);
return PLOT_X + ((lp - lo) / (hi - lo)) * PLOT_W;
}
function yOfPL(pl) {
const lpl = log(max(pl, PL_MIN)) / log(10);
const lo = log(PL_MIN) / log(10);
const hi = log(PL_MAX) / log(10);
return PLOT_Y + PLOT_H - ((lpl - lo) / (hi - lo)) * PLOT_H;
}
// ---------------------------------------------------------------------
// Main log-log plot region.
// ---------------------------------------------------------------------
function drawPlot(pCur, dCur, PLCur) {
// background panel
noStroke(); fill(28);
rect(PLOT_X - 4, PLOT_Y - 4, PLOT_W + 8, PLOT_H + 8, 4);
// grid lines (decades)
stroke(...SCRATCH); strokeWeight(1); noFill();
for (let e = -4; e <= -1; e++) {
const x = xOfP(pow(10, e));
line(x, PLOT_Y, x, PLOT_Y + PLOT_H);
}
for (let e = -15; e <= 0; e += 3) {
const y = yOfPL(pow(10, e));
line(PLOT_X, y, PLOT_X + PLOT_W, y);
}
// axis frame
stroke(...STRUCT); strokeWeight(1.5); noFill();
rect(PLOT_X, PLOT_Y, PLOT_W, PLOT_H);
// axis tick labels
noStroke(); fill(...DIM); textSize(10); textAlign(CENTER, TOP);
for (let e = -4; e <= -1; e++) {
text('1e' + e, xOfP(pow(10, e)), PLOT_Y + PLOT_H + 4);
}
textAlign(RIGHT, CENTER);
for (let e = -15; e <= 0; e += 3) {
text('1e' + e, PLOT_X - 4, yOfPL(pow(10, e)));
}
// axis titles
fill(FG); textSize(11);
textAlign(CENTER, TOP);
text('physical error per gate, p', PLOT_X + PLOT_W / 2, PLOT_Y + PLOT_H + 20);
push();
translate(PLOT_X - 38, PLOT_Y + PLOT_H / 2);
rotate(-HALF_PI);
textAlign(CENTER, BOTTOM);
text('logical error per cycle, P_L', 0, 0);
pop();
// threshold line at p = p_th (dashed magenta)
const xTh = xOfP(P_TH);
drawDashedV(xTh, PLOT_Y, PLOT_Y + PLOT_H, ACCENT, 6, 4);
noStroke(); fill(...ACCENT); textSize(10); textAlign(LEFT, BOTTOM);
text('threshold p_th = 0.01', xTh + 4, PLOT_Y + 12);
// family of curves, one per d in D_LIST
for (const d of D_LIST) {
const isCur = (d === dCur);
if (isCur) {
stroke(...TRAJ); strokeWeight(2.4);
} else {
// colour by whether the curve crosses threshold inside the window:
// all do, so colour by below/above with a soft gradient feel
stroke(...COLD, 180); strokeWeight(1.4);
}
noFill();
beginShape();
for (let i = 0; i <= 200; i++) {
const t = i / 200;
const lp = lerp(log(P_MIN) / log(10), log(P_MAX) / log(10), t);
const p = pow(10, lp);
const pl = logicalErrorRate(p, d);
vertex(xOfP(p), yOfPL(pl));
}
endShape();
// d label to the right of the plot at where curve exits the right side
const pRight = P_MAX;
const plRight = logicalErrorRate(pRight, d);
noStroke();
fill(...(isCur ? TRAJ : [...COLD, 200]));
textSize(10); textAlign(LEFT, CENTER);
text('d=' + d, PLOT_X + PLOT_W + 4, constrain(yOfPL(plRight), PLOT_Y + 6, PLOT_Y + PLOT_H - 6));
}
// user marker: vertical line at current p, dot at (p, P_L(d_cur))
stroke(...TRAJ, 180); strokeWeight(1);
line(xOfP(pCur), PLOT_Y, xOfP(pCur), PLOT_Y + PLOT_H);
noStroke(); fill(...TRAJ);
ellipse(xOfP(pCur), yOfPL(PLCur), 8, 8);
// small dots for the marker on every other curve in the family
for (const d of D_LIST) {
if (d === dCur) continue;
const pl = logicalErrorRate(pCur, d);
noStroke(); fill(...COLD, 200);
ellipse(xOfP(pCur), yOfPL(pl), 4, 4);
}
}
function drawDashedV(x, y0, y1, col, dashLen, gapLen) {
stroke(...col); strokeWeight(1.2); noFill();
let y = y0;
while (y < y1) {
const y2 = min(y + dashLen, y1);
line(x, y, x, y2);
y = y2 + gapLen;
}
}
// ---------------------------------------------------------------------
// Right-side panel: logical-qubit stack + success-probability bar +
// numeric readouts.
// ---------------------------------------------------------------------
function drawPanel(d, nLog, nPhys, PL, pSuccess) {
// panel background
noStroke(); fill(28);
rect(PANEL_X - 4, PANEL_Y - 4, PANEL_W + 8, PANEL_H + 8, 4);
// header
fill(FG); textSize(12); textAlign(LEFT, TOP);
text('budget at d = ' + d, PANEL_X + 6, PANEL_Y + 4);
// numeric readouts
textSize(11); fill(...DIM);
let y = PANEL_Y + 22;
text('N_phys = ' + nfc(nPhys, 0), PANEL_X + 6, y); y += 14;
text('cost/logical = ' + (2 * d * d) + ' physical', PANEL_X + 6, y); y += 14;
text('N_logical = ' + nfc(nLog, 0), PANEL_X + 6, y); y += 14;
text('P_L = ' + formatSci(PL), PANEL_X + 6, y); y += 14;
text('D_circuit = ' + nfc(D_CIRCUIT, 0) + ' cycles', PANEL_X + 6, y); y += 14;
text('P_success = ' + nf(pSuccess * 100, 1, 3) + ' %', PANEL_X + 6, y); y += 18;
// logical-qubit tile stack: max 100 tiles drawn, scaled down if more
const tilesShown = min(nLog, 100);
const cols = 10;
const tileW = 16, tileH = 12, gap = 2;
const stackX = PANEL_X + 6;
const stackY = y + 4;
fill(...DIM); textSize(10);
text('logical qubits (cap 100):', stackX, y); y += 4;
for (let i = 0; i < tilesShown; i++) {
const cx = stackX + (i % cols) * (tileW + gap);
const cy = stackY + floor(i / cols) * (tileH + gap);
noStroke(); fill(...TRAJ, 200);
rect(cx, cy, tileW, tileH, 2);
}
// empty slots
for (let i = tilesShown; i < 100; i++) {
const cx = stackX + (i % cols) * (tileW + gap);
const cy = stackY + floor(i / cols) * (tileH + gap);
noStroke(); fill(...STRUCT, 60);
rect(cx, cy, tileW, tileH, 2);
}
// success-probability bar (bottom of panel)
const barX = PANEL_X + 6;
const barY = PANEL_Y + PANEL_H - 30;
const barW = PANEL_W - 12;
const barH = 14;
noStroke(); fill(...STRUCT, 70);
rect(barX, barY, barW, barH, 2);
fill(...GAUGE);
rect(barX, barY, barW * constrain(pSuccess, 0, 1), barH, 2);
fill(...DIM); textSize(10); textAlign(LEFT, BOTTOM);
text('circuit success @ N_log x ' + nfc(D_CIRCUIT, 0) + ' cycles',
barX, barY - 2);
}
// ---------------------------------------------------------------------
// Slider labels live just above each slider.
// ---------------------------------------------------------------------
function drawSliderLabels(p, d, nPhys) {
noStroke(); fill(...DIM); textSize(11); textAlign(LEFT, BOTTOM);
text('p (physical error / gate) = ' + formatSci(p), 60, 408);
text('d (code distance) = ' + d, 60, 443);
text('N_phys (physical qubits) = ' + nfc(nPhys, 0), 60, 478);
}
// ---------------------------------------------------------------------
// Canonical equation in ASCII, bottom-right corner.
// ---------------------------------------------------------------------
function drawEquation() {
noStroke(); fill(...DIM); textSize(11); textAlign(RIGHT, BOTTOM);
text('P_L = A * (p / p_th)^((d+1)/2)', width - 12, height - 24);
text('A = 0.03, p_th = 0.01', width - 12, height - 10);
}
// ---------------------------------------------------------------------
// HUD: title bar in the top-left.
// ---------------------------------------------------------------------
function drawHUD() {
noStroke(); fill(0, 180);
rect(8, 8, 360, 38, 3);
fill(255); textSize(20); textStyle(BOLD); textAlign(LEFT, TOP);
text(TITLE, 16, 12);
textSize(11); textStyle(NORMAL); fill(...DIM);
text('Wikitube microsim . en.wikitube.io/wiki/' + ARTICLE, 16, 32);
// short top-right hint
noStroke(); fill(...DIM); textSize(10); textAlign(RIGHT, TOP);
text('drag sliders; magenta line = code threshold',
width - 12, 14);
text('curves family: d in {3, 5, 7, 11, 17, 25}',
width - 12, 28);
}
// ---------------------------------------------------------------------
// Format a positive number in compact scientific notation, e.g.
// formatSci(3.14e-5) -> "3.14e-5"
// ---------------------------------------------------------------------
function formatSci(x) {
if (x <= 0) return '0';
const e = floor(log(x) / log(10));
const m = x / pow(10, e);
return nf(m, 1, 2) + 'e' + e;
}
```
## Links (Wikipedia order)
<!-- injected from _registry/childlinks/Quantum_computing.json (2026-07-30T02:09:12Z) -->
`1-bit_computing` · `12-bit_computing` · `128-bit_computing` · `16-bit_computing` · `24-bit_computing` · `256-bit_computing` · `32-bit_computing` · `4-bit_computing` · `48-bit_computing` · `512-bit_computing` · `64-bit_computing` · `8-bit_computing` · `ACPI` · `ARM_architecture_family` · `Abelian_group` · `Abstract_machine` · `Adder_(electronics)` · `Address_decoder` · `Address_generation_unit` · `Addressing_mode` · `Adiabatic_quantum_computation` · `Adiabatic_theorem` · `Advanced_Power_Management` · `Adversary_(cryptography)` · `Alexei_Kitaev` · `Algorithmic_cooling` · `Alice_and_Bob` · `AlphaEvolve` · `Alternating_Turing_machine` · [[Aluminium]] · `American_Physical_Society` · `Ammonia` · `Amplitude_amplification` · `Analogue_electronics` · `Andrew_Hodges` · `Anti-gravity` · `Anyon` · `Apollo_Guidance_Computer` · `Application-specific_instruction_set_processor` · `Application-specific_integrated_circuit` · `Applied_Physics_Reviews` · `Arithmetic_logic_unit` · [[Artificial_intelligence]] · `Association_for_Computing_Machinery` · `Atom` · `BB84` · `BHT_algorithm` · `BPP_(complexity)` · `BQP` · `Bacon–Shor_code` · `Barrel_processor` · `Barrel_shifter` · `Barton_Zwiebach` · `Baseband_processor` · `Basic_Books` · `Bell's_theorem` · `Bell_test` · `Bernstein–Vazirani_algorithm` · `Binary_decoder` · `Binary_multiplier` · [[Binary_number]] · `Bit` · `Bit-level_parallelism` · `Bit-serial_architecture` · `Bit_slicing` · [[Black_box]] · `Bloch_sphere` · `Boaz_Barak` · `Boltzmann_machine` · `Boolean_circuit` · `Boolean_satisfiability_problem` · `Born_rule` · `Boson_sampling` · `Branch_predictor` · `Branch_target_predictor` · `Bra–ket_notation` · `Bus_(computing)` · `CPU_cache` · `CPU_multiplier` · `CSS_code` · `Cache_(computing)` · `Cache_coherence` · `Cache_hierarchy` · `Cache_performance_measurement_and_metric` · `Cache_replacement_policies` · `California_Institute_of_Technology` · `Cambridge,_Massachusetts` · `Carlton_M._Caves` · `Casimir_effect` · `Cat_state` · `Cavity_quantum_electrodynamics` · `Cellular_architecture` · [[Cellular_automaton]] · `Central_processing_unit` · `Charge_qubit` · `Charles_H._Bennett_(physicist)` · `China` · `Chinese_Academy_of_Sciences` · `Chip_carrier` · `Church–Turing_thesis` · `Circuit_(computer_science)` · `Circuit_quantum_electrodynamics` · `Cirq` · `Classic_RISC_pipeline` · `Classical_capacity` · `Classical_electromagnetism` · `Classical_mechanics` · `Clipper_architecture` · `Clock_gating` · `Clock_rate` · `Clock_signal` · `Cloud-based_quantum_computing` · `Cluster_state` · [[Cobalt]] · `Coding_theory` · `Cognitive_computing` · `Collider` · `Combinational_logic` · [[Combinatorial_optimization]] · `Comparison_of_instruction_set_architectures` · `Complementarity_(physics)` · `Complex_instruction_set_computer` · `Complex_number` · `Complex_programmable_logic_device` · `Computability` · `Computability_theory` · `Computational_biology` · `Computational_problem` · `Computer` · [[Computer_architecture]] · `Computer_data_storage` · [[Computer_engineering]] · `Computer_performance` · `Computer_performance_by_orders_of_magnitude` · [[Computer_science]] · `Consciousness_causes_collapse` · `Consistent_histories` · `Continuous-variable_quantum_information` · `Control_unit` · `Cooperative_multitasking` · `Copenhagen_interpretation` · `Coprocessor` · `Counter_(digital)` · `Counter_machine` · `Cross-entropy_benchmarking` · `Cryptanalysis` · `Cryptography` · `Cycles_per_instruction` · `Cypress_PSoC` · `DARPA` · `DEC_Alpha` · `Data_buffer` · `Data_dependency` · `Data_parallelism` · `Dataflow_architecture` · `Datapath` · `David_Deutsch` · `Davisson–Germer_experiment` · `De_Broglie–Bohm_theory` · `Decoy_state` · `Degenerate_energy_levels` · `Delayed-choice_quantum_eraser` · `Delhi` · `Density_matrix` · `Derek_Abbott` · `Deterministic_finite_automaton` · `Deutsch–Jozsa_algorithm` · `DiVincenzo's_criteria` · `Diffie–Hellman_key_exchange` · `Digital_electronics` · `Digital_signal_processor` · `Dihedral_group` · [[Dilution_refrigerator]] · `Dimension_(vector_space)` · `Dirac_equation` · `Discrete_logarithm` · `Double-slit_experiment` · `Drug_discovery` · `Dynamic_frequency_scaling` · `Dynamic_voltage_scaling` · `ETRAX_CRIS` · `Eastin–Knill_theorem` · `Edward_Fredkin` · `Einstein–Podolsky–Rosen_paradox` · `Electronic_circuit` · `Electronic_quantum_holography` · `Elitzur–Vaidman_bomb_tester` · `Embedded_system` · [[Emerging_technologies]] · `Encyclopedia_of_Mathematics` · `Encyclopædia_Britannica` · `Endianness` · `Energy_level` · `Ensemble_interpretation` · `Entanglement-assisted_classical_capacity` · `Entanglement-assisted_stabilizer_formalism` · `Entanglement_distillation` · `Entanglement_swapping` · [[Europium]] · `Evolutionary_algorithm` · `Exact_quantum_polynomial_time` · `Excited_state` · `Execution_unit` · `Experimental_physics` · `Explicit_data_graph_execution` · `Explicitly_parallel_instruction_computing` · `FIFO_(electronic)` · `Fabric_computing` · `False_sharing` · `Field-programmable_gate_array` · `Field-programmable_object_array` · [[Finite-state_machine]] · `Five-qubit_error_correcting_code` · `Floating-point_unit` · `Flux_qubit` · `Flynn's_taxonomy` · `Franck–Hertz_experiment` · `Function_composition_(computer_science)` · `Gate_array` · `General-purpose_computing_on_graphics_processing_units` · `Generative_adversarial_network` · `Gil_Kalai` · `Gilles_Brassard` · `Gleason's_theorem` · `Glossary_of_elementary_quantum_mechanics` · `Glossary_of_quantum_computing` · `Glue_logic` · `Gnu_code` · `Google` · `Google_AI` · `Google_DeepMind` · `Google_Quantum_AI` · `Gottesman–Kitaev–Preskill_code` · `Gottesman–Knill_theorem` · [[Graphics_processing_unit]] · `Ground_state` · `Grover's_algorithm` · `HHL_algorithm` · `Haber_process` · `Halting_problem` · `Hamiltonian_(quantum_mechanics)` · `Hamiltonian_quantum_computation` · `Hardware_acceleration` · `Hardware_register` · `Hardware_security_module` · `Harvard_University` · `Harvard_architecture` · `Hazard_(computer_architecture)` · `Heisenberg_picture` · [[Helium-3]] · `Heterogeneous_System_Architecture` · `Heterogeneous_computing` · `Hidden-variable_theory` · `Hidden_matching_problem` · `Hidden_subgroup_problem` · `History_of_general-purpose_CPUs` · `History_of_quantum_field_theory` · `History_of_quantum_mechanics` · `Holevo's_theorem` · `Holographic_principle` · `Hyper-threading` · `Hypercomputation` · `IA-64` · `IBM` · `IBM_Heron` · `IBM_POWER_architecture` · `IBM_Q_System_One` · `IBM_Q_System_Two` · `IBM_System/360_architecture` · `IBM_System/370` · `IBM_System/390` · `IEEE_Spectrum` · `Image_processor` · `Immersion_(virtual_reality)` · `India` · `Information_security` · `Instruction-level_parallelism` · `Instruction_cycle` · `Instruction_pipelining` · `Instruction_set_architecture` · `Instruction_unit` · `Instructions_per_cycle` · `Instructions_per_second` · `Integer_factorization` · `Integrated_circuit` · `Intelligence_Advanced_Research_Projects_Activity` · `Interaction_picture` · `International_Telecommunication_Union` · `Interpretations_of_quantum_mechanics` · `Introduction_to_quantum_mechanics` · `Ionizing_radiation` · `Ising_model` · [[Isolated_system]] · `John_Preskill` · `Jones_polynomial` · `KLM_protocol` · `Kane_quantum_computer` · `Kelvin` · `Klein–Gordon_equation` · `LOCC` · `Large_language_model` · `Lattice-based_cryptography` · `Leonard_Susskind` · `Libquantum` · [[Linear_algebra]] · `Linear_combination` · `Linear_optical_quantum_computing` · `List_of_computer_books` · `List_of_emerging_technologies` · `List_of_quantum_algorithms` · `List_of_quantum_key_distribution_protocols` · `List_of_quantum_processors` · `Load–store_architecture` · `Load–store_unit` · `Local_hidden-variable_theory` · [[Logic_gate]] · `Low-density_parity-check_code` · `M32R` · `MIPS-X` · `MIPS_architecture` · [[Machine_learning]] · `Mach–Zehnder_interferometer` · `Magic_state_distillation` · `Majorana_equation` · `Manhattan_Project` · `Many-worlds_interpretation` · `Manycore_processor` · `Massachusetts_Institute_of_Technology` · `Mathematical_formulation_of_quantum_mechanics` · `Matrix_(mathematics)` · `Matrix_mechanics` · `Matrix_multiplication` · `McEliece_cryptosystem` · `Measurement_in_quantum_mechanics` · `Measurement_problem` · `Memory-level_parallelism` · `Memory_address_register` · `Memory_buffer_register` · `Memory_controller` · `Memory_dependence_prediction` · `Memory_hierarchy` · `Memory_management_unit` · `Michael_Freedman` · `Michael_Nielsen` · `MicroBlaze` · `Microarchitecture` · `Microcode` · `Microcontroller` · `Microprocessor` · `Microprocessor_chronology` · `Minimal_instruction_set_computer` · `Mixed-signal_integrated_circuit` · `Mobile_processor` · `Model_of_computation` · `Modified_Harvard_architecture` · `Molecular_geometry` · `Monogamy_of_entanglement` · `Motorola_68000_series` · `Multi-chip_module` · `Multi-core_processor` · `Multiple_instruction,_multiple_data` · `Multiple_instruction,_single_data` · `Multiplexer` · [[Multiprocessing]] · [[Multithreading_(computer_architecture)]] · `N._David_Mermin` · `NASA` · `NP_(complexity)` · `Nanotechnology` · `National_Institute_of_Standards_and_Technology` · `Natural_computing` · `Nature_(journal)` · `Nature_Electronics` · `Network_on_a_chip` · `Network_processor` · `Neutral_atom_quantum_computer` · `New_Scientist` · `New_York_City` · `Nitrogen-vacancy_center` · `Nitrogen_fixation` · `No-broadcasting_theorem` · `No-cloning_theorem` · `No-communication_theorem` · `No-deleting_theorem` · `No-hiding_theorem` · `No-teleportation_theorem` · `No_instruction_set_computing` · `Noise_(signal_processing)` · `Non-local_quantum_computation` · `Non-uniform_memory_access` · `Nondeterministic_Turing_machine` · [[Nuclear_magnetic_resonance]] · `Nuclear_magnetic_resonance_quantum_computer` · `Nuclear_physics` · `Objective-collapse_theory` · `Old_quantum_theory` · `One-instruction_set_computer` · `One-way_quantum_computer` · `One_clean_qubit` · `OpenQASM` · `OpenRISC` · `Operand_forwarding` · `Optical_computing` · `Oracle_machine` · `Orthogonal_instruction_set` · `Out-of-order_execution` · `PDP-11_architecture` · `P_(complexity)` · `Package_on_a_package` · `Parallel_computing` · `Password_cracking` · `Paul_Benioff` · `Paul_Davies` · `Pauli_equation` · `Pell's_equation` · `Performance_per_watt` · `Peter_Shor` · `Phase-space_formulation` · `Phase_qubit` · `Philadelphia` · [[Photon]] · `Physical_and_logical_qubits` · `Physics_processing_unit` · `Pin_grid_array` · `Pipeline_stall` · `Pointer_machine` · `Popper's_experiment` · `Post-quantum_cryptography` · `PostBQP` · `Post–Turing_machine` · `PowerPC` · `Power_ISA` · `Power_Management_Unit` · `Power_management` · `Power_management_integrated_circuit` · `Preemption_(computing)` · `Prime_number` · `Princeton_University` · `Princeton_University_Press` · `Probabilistic_Turing_machine` · `Probability_amplitude` · `Probability_theory` · `Probability_vector` · `Process_(computing)` · `Processor_(computing)` · `Processor_design` · `Processor_register` · `Program_analysis` · `Program_counter` · `Programmable_Array_Logic` · `Programmer` · `Psi_(Greek)` · `Public-key_cryptography` · `QIP_(complexity)` · `QMA` · `Q_Sharp` · `Qiskit` · `Quantum_Computation_and_Quantum_Information` · `Quantum_Fourier_transform` · `Quantum_Turing_machine` · `Quantum_algorithm` · `Quantum_amplifier` · `Quantum_annealing` · `Quantum_biology` · `Quantum_bus` · `Quantum_capacity` · `Quantum_cellular_automaton` · `Quantum_channel` · `Quantum_chaos` · `Quantum_chemistry` · `Quantum_circuit` · `Quantum_cognition` · `Quantum_coin_flipping` · `Quantum_complexity_theory` · `Quantum_computational_chemistry` · `Quantum_computing_scaling_laws` · `Quantum_convolutional_code` · `Quantum_cosmology` · `Quantum_counting_algorithm` · `Quantum_cryptography` · `Quantum_decoherence` · `Quantum_differential_calculus` · `Quantum_dynamics` · `Quantum_energy_teleportation` · `Quantum_engineering` · `Quantum_entanglement` · `Quantum_eraser_experiment` · `Quantum_error_correction` · `Quantum_field_theory` · `Quantum_finite_automaton` · `Quantum_fluctuation` · `Quantum_gate_teleportation` · `Quantum_geometry` · `Quantum_gravity` · `Quantum_image_processing` · `Quantum_imaging` · `Quantum_information` · `Quantum_information_science` · `Quantum_jump` · `Quantum_key_distribution` · `Quantum_logic` · `Quantum_logic_clock` · `Quantum_logic_gate` · `Quantum_machine` · `Quantum_machine_learning` · [[Quantum_mechanics]] · `Quantum_memory` · `Quantum_metamaterial` · `Quantum_metrology` · `Quantum_mind` · `Quantum_money` · `Quantum_mysticism` · `Quantum_network` · `Quantum_neural_network` · `Quantum_nonlocality` · `Quantum_optics` · `Quantum_optimization_algorithms` · `Quantum_phase_estimation_algorithm` · `Quantum_programming` · `Quantum_secret_sharing` · `Quantum_sensor` · `Quantum_simulator` · `Quantum_spacetime` · `Quantum_state` · `Quantum_state_purification` · `Quantum_statistical_mechanics` · `Quantum_stochastic_calculus` · `Quantum_superposition` · `Quantum_supremacy` · `Quantum_teleportation` · `Quantum_tunnelling` · `Quantum_volume` · `Qubit` · `Queue_automaton` · `Quil_(instruction_set_architecture)` · `RISC-V` · `ROM_image` · `Random-access_machine` · `Random-access_stored-program_machine` · `Random_number_generation` · `Randomized_algorithm` · `Randomized_benchmarking` · `Rare-earth_element` · `Rarita–Schwinger_equation` · `Re-order_buffer` · `Reduced_instruction_set_computer` · `Register_file` · `Register_machine` · `Register_renaming` · `Register–memory_architecture` · `Relational_quantum_mechanics` · `Relativistic_quantum_mechanics` · `Relaxation_(NMR)` · `Reservation_station` · `Reviews_of_Modern_Physics` · `Richard_Feynman` · `Rigetti_Computing` · `Rydberg_formula` · `SARG04` · `SPARC` · `SUPS` · `SWAR` · `San_Jose,_California` · `Sanjeev_Arora` · `Santa_Fe,_New_Mexico` · `Scalar_processor` · `Scattering` · `Schrödinger's_cat` · [[Schrödinger_equation]] · `Schrödinger_picture` · `Scoreboarding` · `Scott_Aaronson` · `Scratchpad_memory` · `Secure_cryptoprocessor` · `Semiconductor` · [[Semiconductor_device_fabrication]] · [[Sequential_logic]] · `Seth_Lloyd` · `Shor's_algorithm` · `Shor_code` · [[Silicon]] · `Simon's_problem` · `Simultaneous_and_heterogeneous_multithreading` · `Simultaneous_multithreading` · `Single-core` · `Single_instruction,_multiple_data` · `Single_instruction,_multiple_threads` · `Single_instruction,_single_data` · `Single_program,_multiple_data` · `Soft_microprocessor` · `Solovay–Kitaev_theorem` · `Speculative_execution` · `Speculative_multithreading` · [[Spin_(physics)]] · `Spin_qubit_quantum_computer` · `Spin–lattice_relaxation` · `Spin–spin_relaxation` · `Springer_Nature` · `Springer_Science+Business_Media` · `Stabilizer_code` · `Stack_machine` · `Stack_register` · `Standard_basis` · `Stanford_Encyclopedia_of_Philosophy` · `Stanford_MIPS` · `Status_register` · `Steane_code` · `Stern–Gerlach_experiment` · `Steven_Weinberg` · `Stored-program_computer` · [[Stream_processing]] · `Sum-addressed_decoder` · `Summit_(supercomputer)` · `SuperH` · `Supercomputer` · `Superconducting_quantum_computing` · `Superdense_coding` · `Superdeterminism` · `Superscalar_processor` · `Switch` · `Symmetric-key_algorithm` · `Symmetry_in_quantum_mechanics` · `Symposium_on_Foundations_of_Computer_Science` · `System_in_a_package` · `System_on_a_chip` · `TRIPS_architecture` · `Tanja_Lange` · `Task_parallelism` · `Temporal_multithreading` · [[Tensor]] · `Tensor_Processing_Unit` · `Tensor_product` · `The_New_York_Times` · `Theoretical_computer_science` · `Thermoacoustic_heat_engine` · `Thread_(computing)` · `Three-dimensional_integrated_circuit` · `Threshold_theorem` · `Tick–tock_model` · `Tile_processor` · `Time_complexity` · `Timeline_of_quantum_computing_and_communication` · `Timeline_of_quantum_mechanics` · `Toffoli_gate` · `Tomasulo's_algorithm` · `Tommaso_Toffoli` · `Topological_quantum_computer` · `Transactional_interpretation` · `Transactions_per_second` · `Transistor_count` · `Translation_lookaside_buffer` · `Transmon` · `Transport_triggered_architecture` · `Trapped-ion_quantum_computer` · `Turing_machine` · `Ultracold_atom` · [[Uncertainty_principle]] · `Unconventional_computing` · `Undecidable_problem` · `Unicore` · `Uniform_memory_access` · `Unitary_matrix` · `Universal_Turing_machine` · `Universal_wave_function` · `University_of_Science_and_Technology_of_China` · `Unstructured_data` · `VAX` · `VISC_architecture` · `Variational_quantum_eigensolver` · `Vector_(mathematics_and_physics)` · `Vector_processor` · `Vector_space` · `Very_long_instruction_word` · `Virtual_memory` · `Vision_processing_unit` · [[Von_Neumann_architecture]] · `Wafer_(electronics)` · `Wave_function` · `Wave_function_collapse` · `Wave_interference` · `Wave–particle_duality` · [[Wayback_Machine]] · `Weyl_equation` · `Wheeler's_delayed-choice_experiment` · `Wide-issue` · `Wigner's_friend` · `Word_(computer_architecture)` · `World_War_II` · `World_War_II_cryptography` · `Write_buffer` · `X86` · `Yuri_Manin` · `Z/Architecture` · `Zeno_machine` · [[Zero-point_energy]]
## From the Real GENERATIVE library
*Quantum Computing — placed from the Real G.E.N.E.R.A.T.I.V.E. course library (Computation and Cybersecurity room). Source: Wikimedia Commons (via Wikipedia article media). [Details & license](https://commons.wikimedia.org/wiki/File:Bloch_sphere.svg).*
> A quantum computer is a computer that exploits quantum mechanical phenomena. On small scales, physical matter exhibits properties of both particles and waves, and quantum computing leverages this behavior using specialized hardware. ([Wikipedia](https://en.wikipedia.org/wiki/Quantum_Computing))
<!-- REAL-GENERATIVE-MEDIA:END -->
<!-- LOCAL-MEDIA-PASS:START -->
## From the vault media library
!Quantum computing thumb.png
*Quantum Computing — from the vault's own media holdings, placed 2026-07-09. MTN / Wikitube.io original · CC BY-SA 4.0.*
<!-- LOCAL-MEDIA-PASS:END -->
> **Room:** [[Helium]] · **Status:** ✅ shipped
## Overview
**Quantum computing** is the branch of computation that manipulates [[Information|information]] encoded in quantum-mechanical degrees of freedom — superposition, entanglement, and interference — to execute algorithms that on certain problems achieve exponential or polynomial speedups over classical computation. The basic unit is the **qubit**, a two-level quantum [[System|system]] whose state lives on the Bloch sphere as the complex superposition α|0⟩ + β|1⟩ with |α|² + |β|² = 1. Universal computation requires a small set of single- and two-qubit gates (typically a Clifford generator plus a non-Clifford T or Toffoli), arranged into circuits whose expected outcome is read out by projective measurement. Landmark algorithms include Shor's polynomial-time integer factoring (1994), Grover's quadratic unstructured search (1996), HHL linear-systems, and the variational families (VQE, QAOA) that drive near-term applications. The dominant hardware platforms — superconducting transmons (IBM, Google, Rigetti), trapped ions (IonQ, Quantinuum), neutral atoms (QuEra, Pasqal), photonics (PsiQuantum, Xanadu), and silicon spins (Intel) — each implement DiVincenzo's five criteria differently but converge on the same [[Engineering|engineering]] imperative: drive single-qubit gate fidelity above the surface-code threshold (≈ 99%) and concatenate physical qubits into fault-tolerant **logical qubits**. Superconducting and spin-qubit platforms run inside helium dilution refrigerators at 10–20 mK to suppress thermal occupation of microwave-frequency transitions, making cryogenic helium the indispensable substrate of gate-model quantum hardware. Practical applications now targeted include cryptanalysis, materials and drug simulation, optimisation, and quantum [[Machine_learning|machine learning]], with utility-scale fault-tolerant systems forecast for the late 2020s.
## See also
- Room hub: [[Helium]]
- p5.js Editor conventions: P5 JS EDITOR
- Wiki root: MAIN
---
*Scaffolded by `generative-microsim` from row 56 of the Helium sheet on 2026-05-12T02:41:53Z.*
<!-- REAL-GENERATIVE-MEDIA:START -->
<!-- CRAFT-LINK:START g12 -->
*Built to the [[WT!P5_js_Microsim_Master_Class|p5.js Master Class]].*
<!-- CRAFT-LINK:END -->
## Wikipedia : Wikitube
**Strict pair:** [Wikipedia](https://en.wikipedia.org/wiki/Quantum_computing) : [Wikitube](https://en.wikitube.io/wiki/Quantum_computing)
## Previous hub tags
Tree parents: [[Graph_theory]] · [[Information_theory]] · [[Operations_research]].
Legacy hubs: none.
---
*Sources: 1 legacy note. Minted wave 1, 2026-07-30 (v1.6 order).*