Physical and Logical Qubits¶

The quantum-computing layer boundary that realizes an algorithm-facing qubit as encoded states and operations in noisier physical degrees of freedom.

Version: v3 · 2026-09-06 · History
Domain-specific #: 2485
Origin domain: quantum information
Subdomain: quantum error correction
Aliases: Physical-logical qubit distinction, Physical versus logical qubits

Core Idea¶

Physical and logical qubits names a layer distinction in quantum computing. A physical qubit is a controllable physical degree of freedom used through a two-dimensional computational subspace: for example, selected levels of a superconducting circuit, an ion, a spin, or a photonic mode. A logical qubit is the two-dimensional information interface on which an algorithm's states, gates, and measurements are defined. In error-corrected computation that interface is encoded in a larger physical Hilbert space so that specified physical faults can be detected or corrected without learning the encoded amplitudes.

The abstraction is not merely a pair of definitions. It is the mapping that lets architecture be reasoned about at two levels. At the lower level are device states, controls, leakage, noise, measurements, and connectivity. At the upper level are logical basis states, logical observables, logical gates, and logical error rates. A quantum code and its control protocol connect them. An algorithm may therefore request a logical operation such as \(X_L\) or a logical measurement without naming every physical pulse and syndrome decision that realizes it.

For \(k\) logical qubits, an encoding can be represented by an isometry

\[ V:(\mathbb{C}^{2})^{\otimes k}\longrightarrow \mathcal H_{\mathrm{phys}}, \]

whose image \(\mathcal C\) is the code space and whose projector is \(P=VV^{\dagger}\). For an \([[n,k,d]]\) qubit code, \(\mathcal H_{\mathrm{phys}}=(\mathbb C^2)^{\otimes n}\), the code space has dimension \(2^k\), and distance \(d\) determines which sufficiently small physical errors are distinguishable or correctable. The same layer idea also covers subsystem and bosonic codes, where the protected two-dimensional subsystem is not well described as a fixed collection of identical two-level devices.

The retained identity is domain-specific. Its portable skeleton resembles representation, encoding, redundancy, and fault tolerance, but its recognition conditions require quantum code spaces, noncommuting logical observables, syndrome information, quantum noise, and restrictions imposed by measurement and no-cloning.

Structural Signature¶

The recurring structure is:

\[ \text{physical carriers + noise model} \xrightarrow{\text{encoding and checks}} \text{logical code space or subsystem} \xrightarrow{\text{logical controls and readout}} \text{algorithm-visible qubit}. \]

Its mandatory roles are:

Physical carrier. A hardware system with a chosen computational subspace and a specified set of relevant faults. Real carriers can have levels outside that subspace, so leakage may be part of the physical error model.
Logical information space. Two orthogonal logical basis states \(|0_L\rangle\) and \(|1_L\rangle\), supporting states \(\alpha|0_L\rangle+\beta|1_L\rangle\), or an equivalent two-dimensional subsystem.
Encoding relation. A map identifies the logical state with a distributed or higher-dimensional physical realization. The information need not be recoverable from any single constituent.
Error model and protection criterion. A declared family of physical error operators specifies what the code is meant to detect or correct. For exact subspace quantum error correction, the Knill–Laflamme condition is^[1]

\(P E_a^{\dagger}E_bP=c_{ab}P,\)

equivalently \(\langle i_L|E_a^{\dagger}E_b|j_L\rangle=c_{ab}\delta_{ij}\). The syndrome may depend on the error but not on the unknown logical amplitudes. 5. Logical operations and observables. Operators such as \(X_L\) and \(Z_L\) act on the encoded subsystem, preserve or deliberately transform the code space, and reproduce qubit algebra at the logical interface. In a stabilizer code they commute with the stabilizer while representing distinct actions on the code space; \(X_L\) and \(Z_L\) anticommute on the encoded qubit. 6. Syndrome and recovery path. Measurements, classical processing, a decoder, and recovery or frame updates map physical fault evidence back to a logical-state estimate without directly measuring the logical amplitudes. 7. Resource and performance map. Physical counts, check cycles, ancillas, latency, decoder cost, and physical error parameters determine a logical error metric. The mapping is code-, hardware-, operation-, and noise-model-dependent.

Recognition requires both levels and a defensible relation between them. A hardware qubit list with no logical interface is insufficient. So is an abstract circuit wire with no question of physical realization. The abstraction becomes operational when states, operations, errors, and resources can be translated across the boundary.

What It Is Not¶

Not quantum error correction as a whole. Quantum error correction includes code construction, channel models, syndrome extraction, decoding, recovery, bounds, and fault-tolerant protocols. The candidate is the layer distinction those mechanisms establish and expose.
Not the assertion that every logical qubit uses many physical qubits. A bare physical qubit may be treated as the algorithm's logical qubit in an unencoded experiment. Error-corrected logical qubits are often spread across many device qubits, but bosonic codes encode a logical qubit in levels of an oscillator, and subsystem descriptions may allocate physical degrees of freedom differently.
Not classical duplication. An unknown quantum state cannot be copied into independent replicas. Quantum codes distribute information through a larger state space and correlations; error syndromes reveal fault information without cloning or reading the encoded amplitudes.
Not a guarantee of improved performance. Encoding and checks introduce new fault locations. A small or poorly matched code can have a logical error rate worse than a physical baseline. “Logical” identifies the information layer; break-even or error suppression is an achieved performance relation, not part of the word alone.
Not merely longer coherence time. Storage lifetime is one metric. A usable logical qubit also needs initialization, measurement, and an appropriate set of logical operations, each with its own error and leakage behavior.
Not a topological qubit. Topological protection is one family of physical and code-level realizations. Logical qubits can be built with stabilizer, concatenated, subsystem, bosonic, erasure, or other codes, and a claimed topological physical device is not automatically a fault-tolerant logical qubit.
Not the same as a logical circuit wire. Circuit diagrams deliberately suppress implementation, but the present abstraction includes the explicit realization and performance map between the circuit-level qubit and its physical substrate.

Scope of Application¶

The home domain is quantum information, especially quantum error correction, fault-tolerant quantum computation, and quantum-computer architecture. The distinction recurs in code theory, experimental demonstrations, hardware roadmaps, compiler and resource-estimation stacks, decoder design, benchmarking, and comparisons of protected memories and logical gates.

In coding theory, \([[n,k,d]]\) parameters state how many logical qubits are embedded in how many physical qubits and how distance constrains correctability. In stabilizer practice, check operators define the code space and repeated syndrome measurements supply evidence for a decoder. In architecture, a resource estimate distinguishes logical-qubit width and logical-gate depth from the physical data qubits, measurement ancillas, routing area, factories, and cycles required to realize them. In experiments, physical error events and logical failure are reported separately so that increasing code distance can be tested rather than assumed.

The scope includes memories, state preparation, gates, lattice surgery, braiding, teleportation-based operations, and logical measurement. It also includes encodings into oscillators or other higher-dimensional systems because the key relation is between a physical Hilbert space and a protected two-dimensional logical subsystem, not a literal count of fabricated two-level components.

The scope excludes metaphorical “physical versus logical” language in ordinary software, classical error-correcting bits, and generic abstraction layers that do not preserve quantum states or operations. It does not decide which hardware modality or code family is best.

Clarity¶

The distinction prevents three common denominator errors.

First, “qubit count” is ambiguous. A processor with \(N\) addressable physical qubits does not thereby provide \(N\) useful fault-tolerant logical qubits. The code, target logical error, check ancillas, connectivity, leakage handling, and logical operation set determine the conversion. Reports should say whether a count refers to data carriers, all physical devices used in a code cycle, encoded qubits, or algorithmic logical qubits.

Second, “error rate” is ambiguous. Physical gate infidelity, measurement error, detection-event probability, logical error per round, and logical operation infidelity are not interchangeable. A physical-to-logical claim must name the operation, time unit, code distance, decoder, postselection policy, and noise conditions.

Third, “encoded” is not equivalent to “fault tolerant.” A codeword may detect certain faults while an encoding circuit, recovery circuit, or logical gate propagates one fault into an uncorrectable error. The diagnostic question is not simply “is there a code?” but “does every relevant operation preserve the promised effective fault order under the declared fault model?”

A concise recognition test is: can one state the physical carrier, logical subspace, encoding, correctable error set, syndrome/recovery path, logical observables, and physical-to-logical performance metric? If any of those is absent, the phrase may be rhetorical or incomplete rather than an implemented physical–logical qubit abstraction.

Manages Complexity¶

The abstraction compresses a large quantum control system into an algorithm-facing unit. Without the layer boundary, an algorithm designer would need to reason about every microwave pulse, ion interaction, stabilizer measurement, decoder decision, and calibration drift. With it, a logical-qubit contract can state supported logical gates, measurements, latency, and effective failure probabilities while the lower layer remains replaceable within those guarantees.

It also makes overhead comparable. A target logical failure probability can be translated into code distance and physical resources only after a noise model and implementation are chosen. Conversely, a device error model can be propagated through check circuits and a decoder to estimate logical performance. The distinction therefore keeps quantities at their proper level rather than hiding physical overhead inside an undifferentiated “qubit.”

Finally, it localizes verification. Device characterization asks whether physical operations satisfy the assumed noise envelope. Code verification asks whether the error set is correctable. Decoder evaluation asks whether syndromes are interpreted effectively. Logical benchmarking asks whether the assembled layer meets its interface contract. A failure can then be attributed to a layer or to a mismatch between layers.

Abstract Reasoning¶

The abstraction supports a standard sequence of inferences.

Given a code projector \(P\) and candidate errors \(\{E_a\}\), test the Knill–Laflamme condition. If it holds, a recovery channel exists for that error set; this does not yet show that a noisy fault-tolerant implementation realizes the recovery reliably. For a nondegenerate \([[n,k,d]]\) code, distance \(d\) permits correction of arbitrary errors on at most \(t=\lfloor(d-1)/2\rfloor\) physical qubits^[2]. Degeneracy and structured noise require more careful language, so distance alone is not a full performance prediction.

For stabilizer codes, determine the common eigenspace of the stabilizer group, select representatives of logical operators from the normalizer modulo stabilizers, and verify the encoded commutation relations. Syndrome outcomes distinguish equivalence classes of faults while leaving the logical superposition unresolved. A decoder then selects a correction class or updates a Pauli frame. If the combined physical error and chosen correction differ from identity by a nontrivial logical operator, a logical failure has occurred.

For scaling claims, compare at least two code sizes under a controlled physical regime. If logical error falls as distance or concatenation level increases, the implementation shows suppression in that regime. A threshold theorem licenses asymptotic suppression only under its stated noise and locality hypotheses; it is not a universal constant applicable to all hardware. Below-threshold physical components are therefore necessary within the theorem's model, while adequate syndrome circuits, decoding, and fault-tolerant logical operations remain required.

For architecture, work backward from an algorithmic error budget. Allocate acceptable logical failure across memories and operations, choose a code and distance, estimate cycles and ancillas, then check that the resulting physical workload remains within the assumed error model. This exposes circular plans in which the overhead needed for correction invalidates the physical-error assumptions used to choose that overhead.

Knowledge Transfer¶

Within quantum computing, the same roles transfer across implementations:

transmons, trapped ions, spins, photons, neutral atoms, and oscillator modes occupy the physical carrier role;
stabilizer, subsystem, surface, color, concatenated, bosonic, and erasure codes occupy the encoding/protection scheme role;
parity checks, photon parity, gauge measurements, and flag circuits occupy the syndrome channel role;
minimum-weight matching, belief propagation, lookup, and learned decoders occupy the inference/recovery role;
transversal gates, code deformation, lattice surgery, braiding, teleportation, and calibrated oscillator controls occupy the logical operation role.

This mapping supports valid in-domain transfer. For example, the question “does a physical fault reveal logical information?” applies to both a surface-code check circuit and a bosonic parity measurement even though their substrates differ. So do questions about leakage, correlated faults, decoder latency, break-even, and whether logical controls preserve the code space.

Transfer outside quantum information must stop at the prime skeleton. Software abstraction layers, virtual memory, and classical error-correcting codes may share representation, redundancy, interfaces, and fault tolerance, but they lack the quantum obligations: amplitudes cannot be directly inspected, unknown states cannot be cloned, measurements disturb state, correctability is expressed on a code subspace or subsystem, and logical observables can be noncommuting. Those external cases instantiate broader primes rather than this domain node.

Examples¶

Three-qubit repetition encoding¶

The states

\[ |0_L\rangle=|000\rangle,\qquad |1_L\rangle=|111\rangle \]

encode one logical qubit into three physical qubits against a single bit-flip error. Measuring the commuting parities \(Z_1Z_2\) and \(Z_2Z_3\) distinguishes which single position flipped without distinguishing \(\alpha|0_L\rangle+\beta|1_L\rangle\) by its amplitudes. Majority recovery restores the code state. Logical \(X_L=X_1X_2X_3\) swaps the codewords, while a representative logical \(Z_L\) can be any single \(Z_i\) on the code space. This is a clean demonstration of the two layers, but it does not correct arbitrary single-qubit errors and is not by itself a complete fault-tolerant computer.

Surface-code scaling¶

In a planar surface code, a logical qubit is stored nonlocally across data qubits, with stabilizer measurements repeated through ancillary measurement qubits. Logical \(X_L\) and \(Z_L\) are extended operator strings whose anticommutation defines the encoded qubit. Fowler and colleagues explain how logical qubits and logical gates are realized in the array^[3]. Google Quantum AI's 2023 experiment compared a distance-5 instance using 25 data and 24 measure qubits with distance-3 subsets using 9 data and 8 measure qubits. Over 25 cycles, the reported distance-5 logical error per cycle, \(2.914\%\pm0.016\%\), was modestly below the mean distance-3 value, \(3.028\%\pm0.023\%\)^[4]. The example matters because it measures the desired direction of the physical-to-logical scaling relation rather than inferring protection from encoding alone.

A logical qubit in an oscillator¶

Heeres and colleagues encoded a logical qubit in a four-component cat-state subspace of a superconducting cavity and implemented a universal set of single-logical-qubit controls^[5]. The physical system included an oscillator coupled to a transmon; the logical information occupied a chosen two-dimensional subspace of the oscillator's larger Hilbert space. Photon parity supplied error information, and shaped controls implemented logical transformations. This case disproves the simplistic rule that a logical qubit is always “many physical qubits”: the invariant is a protected logical subsystem realized in richer physical degrees of freedom.

Threshold reasoning¶

Concatenated-code threshold proofs replace each logical location by a fault-tolerant simulation at a lower level and bound malignant combinations of physical faults. Aliferis, Gottesman, and Preskill proved a threshold result for concatenated distance-three codes under specified stochastic and correlated-noise models^[6]. The result supports the conditional inference that sufficiently low physical fault strength allows arbitrarily accurate logical simulation with overhead. It does not support quoting that paper's numerical bound as a universal hardware threshold, because the gadgets, code, noise model, and counting method are part of the theorem.

Structural Tensions¶

Protection vs. overhead¶

Adding carriers and checks can increase distance and suppress logical faults, but each added operation creates fault locations, latency, calibration demands, and decoder load. The proper diagnostic is measured or bounded logical error at the same task boundary, not physical-qubit count alone.

Syndrome visibility vs. logical privacy¶

The recovery process needs enough information to identify a correctable error class, yet measurement of the logical amplitudes would destroy the state. Quantum codes resolve this by arranging checks whose outcomes depend on the error syndrome while satisfying logical-state independence for correctable errors. A check that distinguishes \(|0_L\rangle\) from \(|1_L\rangle\) is not a harmless syndrome measurement.

Easy storage vs. usable computation¶

A code may protect an idle logical state but make logical gates, initialization, or measurement costly or fault-propagating. The abstraction must cover operations as well as memory. A high-fidelity encoded state with no adequately protected control path is not yet an algorithm-ready logical qubit.

Modelled faults vs. physical reality¶

Distance statements are only as operationally useful as the fault model. Leakage, coherent error, crosstalk, loss, burst faults, biased noise, or decoder delay can violate assumptions behind an independent Pauli-error estimate. Protection must be tested against the actual physical channel or against a justified conservative envelope.

General interface vs. implementation-specific metrics¶

The logical layer deliberately hides physical detail, while trustworthy performance claims require that detail. The resolution is a contract: keep algorithmic reasoning at the logical level, but attach operation-specific error, latency, resource, and assumption metadata to the interface.

Structural–Framed Character¶

This abstraction is strongly structural and lightly framed. Its core roles—physical Hilbert space, code space or subsystem, encoding map, error set, syndrome, recovery, logical operators, and resource/performance translation—can be given mathematically and tested experimentally. The terms “physical” and “logical” reflect an engineering viewpoint, but they do not depend on a particular institution, vendor, or hardware technology.

The unavoidable framing lies in the chosen computational subspace, fault model, acceptable logical error, operation set, and resource boundary. A level that one architecture calls “physical” can itself be an encoded or dressed degree of freedom at a deeper level. Likewise, an experimental paper may call a code-space state logical before it crosses break-even. Those choices affect claims but do not erase the structural invariant: one layer presents a qubit interface implemented by another layer's quantum degrees of freedom.

Assessment: structural with explicit model-relative framing. The abstraction is exact enough for formal reasoning, but performance judgments must carry their assumptions.

Structural Core vs. Domain Accent¶

The portable core is a realized abstraction boundary:

\[ \text{fallible substrate} +\text{encoding} +\text{error evidence and recovery} \longrightarrow \text{protected interface with translated performance}. \]

That skeleton appears in fault-tolerant storage, communication, and computing. The domain accent is decisive, however. The represented object is a two-dimensional quantum subsystem; encodings are isometries into Hilbert space; errors are operators or channels; correctability obeys quantum error-correction conditions; checks must avoid revealing unknown amplitudes; logical observables reproduce noncommuting qubit algebra; and physical control must respect coherence and leakage. Removing those features yields broader Encoding and Decoding, Representation, Redundancy, Abstract Data Type, or Fault Tolerance, not Physical and Logical Qubits.

The candidate therefore survives composite closure. Existing primes reconstruct why layering and protection are useful, but they do not entail a code projector, logical Pauli operators, syndrome-state independence, code distance, or a physical-to-logical quantum error map. It also fails the prime test: its literal identity does not recur outside quantum information, even though its supporting pattern transfers broadly.

Fault Tolerance is the minimal prospective parent. An error-corrected logical qubit is a domain-specific way to continue representing and transforming quantum information despite specified failures of physical components and operations.
Encoding and Decoding describes the isometry into the physical code space and the recovery or readout path, but the logical-qubit distinction also requires quantum error criteria and logical operations.
Representation captures the relation between an algorithm-facing state and its physical realization.
Redundancy helps explain distributed protection, but quantum redundancy is not independent copying and some logical qubits use higher-dimensional modes rather than many nominal qubits.
Abstract Data Type is an interface analogy: logical operations can be specified independently of their implementation. It is related rather than constitutive because the quantum state-space and error-correction obligations are not ordinary data-type semantics.
Superposition and Entanglement are physical resources and state structures used by encodings. They are not parent identities; many superposed or entangled physical qubits do not form a protected logical qubit.

Only prime:fault_tolerance is proposed as a DAG parent. The other relations are explanatory and should not be converted into redundant edges without a later locality review.

Relationships to Other Abstractions¶

Current abstraction Physical and Logical Qubits Domain-specific

Parents (1) — more general patterns this builds on

Physical and Logical Qubits is a kind of Fault Tolerance Prime

Fault Tolerance is the minimal prospective parent.

Children (1) — more specific cases that build on this

Charge Qubit Domain-specific is a kind of Physical and Logical Qubits

Charge Qubit specializes Physical and Logical Qubits at the physical-carrier layer.

Hierarchy paths (3) — routes to 3 parentless roots

Physical and Logical Qubits → Fault Tolerance → Robustness

Show alternative paths (2)

Neighborhood in Abstraction Space¶

Physical and Logical Qubits sits in a sparse region of the domain-specific corpus (85^th percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.

Family — Quantum Communication & Benchmarking (6 abstractions)

Nearest neighbors

Computed from structural-signature embeddings · 2026-09-08

Not to Be Confused With¶

Qubit: the generic two-level quantum information unit. The present node concerns the relation between a physical realization and a logical computational unit.
Quantum error-correcting code: the code is a mathematical or operational scheme; physical/logical layering is the interface and resource distinction produced by applying such a scheme.
Quantum error correction: the wider activity of detecting and reversing quantum noise.
Fault-tolerant quantum computation: the system-level discipline for ensuring that faults during gates, checks, preparation, and measurement do not spread beyond the code's capability. A logical qubit is necessary to many such architectures but is not the whole discipline.
Physical implementation of a qubit: transmon, ion, spin, photon, and quantum dot identify carrier technologies. None entails an encoded logical layer.
Encoded qubit: often a useful near-synonym for logical qubit in error-correction context, but “encoded” alone may denote a state preparation without a complete protected operation set.
Topological qubit: a particular protection strategy or proposed physical realization, not a synonym for every logical qubit.
Virtual qubit or circuit wire: a software/compiler object may denote a logical resource, but it qualifies here only when a physical encoding and error/performance map are in scope.
Logical error: an error acting nontrivially on encoded information, not a defect in reasoning or Boolean logic.

References¶

[1] Knill and Laflamme. “Theory of quantum error-correcting codes”. Physical Review A, 1997. Knill & Laflamme (1997) state and prove this exact correctability condition. registry ↩

[2] Nielsen, Michael A. and Chuang, Isaac L. Quantum Computation and Quantum Information. Cambridge University Press, 2010. Standard textbook result (Nielsen & Chuang, 2010) relating code distance to correctable single-qubit errors, valid for nondegenerate codes as stated. registry ↩

[3] Fowler, Austin G., et al. “Surface Codes”. Physical Review A, 2012. Fowler et al. (2012) provide the standard treatment of logical qubits and logical gates in the surface code. registry ↩

[4] Acharya, et al. “Suppressing quantum errors by scaling a surface code logical qubit”. Nature, 2023. Google Quantum AI (2023) report exactly these qubit counts and logical-error-per-cycle figures for the distance-5 vs. distance-3 comparison. registry ↩

[5] Heeres, et al. “Implementing a universal gate set on a logical qubit encoded in an oscillator”. Nature Communications, 2017. Heeres et al. (2017) encode the logical qubit in a four-component cat-state cavity subspace and implement a universal single-logical-qubit gate set, as described. registry ↩

[6] Aliferis, Gottesman, and Preskill. “Quantum accuracy threshold for concatenated distance-3 code”. Quantum Information and Computation, 2006. Aliferis, Gottesman & Preskill (2006) prove this concatenated distance-3 threshold result under explicit noise-model hypotheses. registry ↩