Quantum computing represents a fundamental shift in computation. By harnessing the principles of quantum mechanics (superposition and entanglement), such machines can solve certain highly complex problems exponentially faster than classical computers. While significant engineering hurdles currently limit their widespread adoption, ongoing research and development suggests a future where quantum systems will act as powerful, specialized accelerators alongside our traditional technologies.

1. Quantum Theory

1.1 The Qubit

In classical computing, information is processed using a basic unit called a bit, which can only represent a logical value of 1 or 0. These values are physically realized using deterministic states, e.g. 0 volts representing 0, and a positive voltage (often ~3.3 volts) representing a 1. In contrast, the fundamental unit of information in the quantum analog of a bit, aptly called qubit, relies on a two level physical system¹. Instead of different voltage levels, a qubit is typically represented by the two polarization states of a photon or the two spin states of an atom. Atomic spin emerges from the combination of spins of the fundamental particles in their nuclei. Using Dirac (bra-ket) notation, these two physical states are denoted as $\ket{0}$ and $\ket{1}$. In this notation, a “bra” ($\bra{}$) represents a row vector, and a “ket” ($\ket{}$) represents a column vector¹. Unlike classical bits that can take on a value of either 0 or 1 at any given moment, qubits exist in both possible values at a given instant, i.e qubits are in superposition¹.

1.2 Quantum Entanglement

Quantum entanglement describes a form of quantum correlation that behaves significantly differently from classical correlation¹. In an entangled quantum state, the specific choice of measurement method applied to the first qubit directly impacts the measurement result of the second qubit¹. For example, if two entangled qubits are manipulated so that measuring one yields a 1, the other is practically guaranteed to yield a 0 upon measurement. This correlation persists regardless of the distance between the entangled systems. For instance, measuring the spin of one particle in an entangled pair that were (somehow) separated by billions of light years, will instantaneously cause the other to acquire the opposite spin². However, such quantum phenomena are observed at quantum scales, and in certain environments, as systems like that are delicate. When they are “observed”, which can be any interaction with the system’s environment³, the delicate superposition and entanglement states are easily destroyed¹. Consequently, one must utilize highly isolated microscopic objects, such as photons or electrons in vacuum chambers at near absolute zero¹.

1.3 Superposition

A quantum system can exist in a linear combination of the basis states⁴. In the case of qubits, this superposition is mathematically expressed as $A\ket{0}+B\ket{1}$, where $A$ and $B$ are complex numbers⁴. The probability amplitude for the qubit to be in the 0 and 1 states are $A$ and $B$ respectively. The actual probabilities of observing the 0 or 1 states are the squared magnitudes of these amplitudes, $|A|^2$ and $|B|^2$, which must add up to 1 (100%). To visualize this abstract concept, a Bloch sphere is used⁴. By Smite-Meister - Own work, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=5829358.

On this three-dimensional sphere, the poles represent the standard $\ket{0}$ and $\ket{1}$ states, but the state of a qubit can be represented by a unit vector pointing to any location on the sphere’s surface⁴. The ability to exist in a linear combination yields a substantial computational advantage known as exponential parallelism. If the system is scaled up to $n$ qubits, then they (their wavefunction) can exist in a simultaneous superposition of $2^n$ states⁴. Hence, when an operation is applied to this $n$-qubit system, the operation is essentially being applied on all $2^n$ states⁴. The exponential scaling qubits offer, forms the theoretical foundation for why quantum computers can drastically outperform classical computers in certain tasks.

1.4 Logic Gates

Classical Gates In classical computing, all information processing is built upon fundamental logical operations. These logical operations are fundamentally mathematical concepts, but they are physically carried out by classical logic gates⁵. These physical devices, typically constructed from transistors, take one or more binary inputs (0s and 1s) and produce a single binary output based on a specific Boolean function. See attached truth tables for common logic operations. Other operations, like NAND or NOR, are just AND followed by NOT, and OR followed by NOT, respectively⁶. For example, a basic binary addition circuit known as a half-adder can be constructed by combining an XOR gate to calculate the sum and an AND gate to determine the carry bit. Through combinations of billions of such gates, programmable classical processors that execute complex algorithms, can be manufactured⁷.

Traditional logic gates are fundamentally irreversible⁸. If an AND gate outputs a 0, it’s physically impossible to retroactively infer whether the initial input state was 00, 01, or 10⁸. This “erasure” of information inevitably generates heat, establishing a strict physical barrier to how efficiently classical computers can operate⁸. Unlike classical computing, the fundamental equations governing quantum mechanics dictate that the time evolution of any isolated quantum system is entirely reversible⁸. Although, a classical gate cannot simply be mapped onto quantum processors, instead classical computations must be rigorously adapted into sequences of reversible quantum gates⁴. Therefore, designing quantum gates requires that they are strictly reversible.

Quantum Gates Unlike classical gates that operate on definitive voltage levels, quantum gates manipulate the probabilities and relative phases of qubits in superposition¹. Single qubit gates physically change a qubit’s state to “point” in different directions on the Bloch sphere¹. For example, a type of gate called the Hadamard gate transforms a definitive state, like a qubit at $\ket{1}$, into a superposition state where the qubit has a 50% probability of being at $\ket{0}$ and 50% at $\ket{1}$¹ (mathematically represented as $\frac{1}{\sqrt{2}}\ket{0}+\frac{1}{\sqrt{2}}\ket{1}$, where $\frac{1}{\sqrt{2}}$ is the probability amplitude, and $(\frac{1}{\sqrt{2}})^2 = \frac{1}{2}$ is the probability).

For any meaningful computation to be done, multi-qubit gates need to be designed and entangled. Take the Controlled-NOT, or CNOT, which is a two qubit logical operation¹. Unlike the classical NOT gate, CNOT has 2 inputs and 2 outputs. One of the inputs and outputs is the control bit, and the other is the target. It leaves the target qubit completely unchanged if the designated control qubit is in the $\ket{0}$ state, but applies a NOT operation on the target if the control qubit is in the $\ket{1}$ state¹. The control qubit, whose output is the same as the input, provides additional information that makes this “computation” completely reversible.

A SWAP gate simply exchanges the quantum states of two independent qubits¹. In traditional programming, swapping two variables requires a temporary memory placeholder:

int a = 1;
int b = 2;

int temp = a; // A third tempeorary register is needed

a = b; // a takes on the value of b
b = temp; // b takes on the value of temp, which is the value of a

(Note that at the lower hardware level, like in assembly language, this process involves different explicit memory movement instructions). However, a quantum SWAP gate achieves this without temporary memory using just three sequential CNOT gates. Three alternating CNOT gates (control-target, target-control, control-target) can swap the qubit states¹⁹. By Rxtreme - Own work, CC BY-SA 4.0, https://commons.wikimedia.org/w/index.php?curid=84768061.

2. Physical Hardware

2.1 Engineering Qubits

Despite decades of established theory, quantum computers aren’t ubiquitous because engineering these systems is very difficult. A physical qubit needs to be isolated from environmental interference, while remaining accessible for computational manipulation¹. Numerous approaches to make qubits have been developed, and other ways are being researched.

One of the leading approaches involves superconducting circuits. Instead of using individual atoms, these make use of microscopic oscillators (inductor-capacitor oscillators, in which electricity oscillates) fabricated on silicon chips¹. When cooled to near absolute zero, it acts as a superconductor, i.e the resistance of the circuit becomes 0. This causes the energy levels to become quantized, effectively functioning as an atom¹.

A second highly viable method is through using trapped ions. EM-fields are used to suspend charged atomic ions in a vacuum chamber¹. The qubit states are defined by the stable energy levels of the ion. Since the energy levels of identical ions are the same, they make really nice qubits that can be manipulated by firing calibrated laser beams¹.

A third approach involves Diamond Nitrogen Vacancy Centers. A pure diamond is made up of a rigid lattice of carbon atoms, and by systematically removing a carbon atom and replacing a neighboring atom with nitrogen, one can create an artificial “defect” in the crystal lattice¹. The isolated electron (specifically its spin) trapped within this defect can serve as a qubit¹.

2.2 Quantum Logic

Once qubits are physically created, how do they interact with quantum gates to perform logic, and how can useful information be extracted? To understand the physical implementation of quantum logic, Nuclear Magnetic Resonance (NMR) is a good example¹. In an NMR quantum computer, the qubits are represented by the spins of the nuclei of certain atoms with a liquid molecule, like Carbon-13 and Hydrogen-1 nuclei in a chloroform molecule. When placed in a powerful, static magnetic field, the spins align either with the field ($\ket{0}$), or against it ($\ket{1}$), providing two different states. To apply a single qubit gate, such as the Hadamard gate to induce a superposition, the molecule is subjected to a precisely timed RF pulse¹. The RF pulse essentially “tips” the spin vector of the targeted nucleus away from the magnetic axis, forcing it into a superposition of both states. By carefully tuning the frequency, duration, and phase of the RF pulse, one can simply force it to acquire a probability amplitude of choice¹.

In an NMR, multi-qubit logic is achieved by exploiting a quantum mechanical interaction between neighboring atoms known as “J-coupling”¹. Because the atomic nuclei are in close proximity within the same molecule, the magnetic state of one nucleus slightly alters the energy environment of its neighbor. And by allowing the system to evolve under these conditions for a certain duration, along with RF pulses for a single qubit, the state of the target spin becomes mathematically entangled with the state of the control spin, physically manifesting the conditional logic required for a CNOT gate¹.

Other hardware approaches can achieve such interactions through different physical phenomena. For instance, in Cavity Quantum Electrodynamics¹⁰, two qubit interactions are facilitated by passing individual atoms through a microwave cavity⁸.

The information can be extracted simply by “observing” the quantum system, as that collapses the probability amplitude into a single definite state. In platforms like superconducting circuits or ion traps, one perform a measurement that essentially asks the qubit, “Are you a 0 or a 1?”, yielding a classical bit of information. In NMR, because the macroscopic liquid sample contains trillions of identical molecules, the output cannot be read from a single molecule¹. Instead, the magnetic field of the spins induces a current in a receiver coil, allowing for information about the system to be measured¹.

3. Current Limitations

3.1 Decoherence

Despite the immense potential of quantum computation, physically realizing them involves overcoming severe physical and engineering limitations. Decoherence is one such problem. In its simplest terms, decoherence can be defined as the “randomization” of a precise quantum state⁸. A quantum system existing in a delicate superposition must remain perfectly isolated from the environment. However, if the system interacts with its surrounding environment, the environment effectively “measures” the quantum state, before any useful computation has been done. This interaction allows for a tiny amounts of information to “leak” out into the environment, which is enough to cause the superposition to spontaneously collapse and randomize⁸. In physical hardware, this loss of quantum coherence is quantified using specific relaxation times. There are two primary parameters where quantum spins lose their synchronization: $T_1$ and $T_2$¹. The $T_1$ parameter, or longitudinal relaxation time, measures how long it takes for a qubit to return to its thermal equilibrium state¹. The $T_2$ parameter is known as the transverse relaxation time, and measures the time it takes for the quantum spins to lose their phase synchronization¹. This transverse relaxation is the physical manifestation of decoherence, and it must be actively combated because it transforms a clean quantum state into a mixed state, in turn destroying the computational information¹.

3.2 Error Correction

To combat decoherence, one must implement error correction, which introduces its own challenges. In classical computing, if a bit is corrupted, error correction protocols simply rely on redundant copies of the data. However, quantum mechanics does not allow for the cloning of an unknown quantum state, making direct redundancy impossible⁴. Furthermore, classical errors are simple bit flips (discrete), whereas quantum errors are continuous, and because a qubit can point anywhere on a 3D sphere, an error could be an infinitely small, continuous rotation of its phase, making it seemingly impossible to accurately identify and correct the exact error⁴. However, it’s possible to actually treat quantum errors mathematically as a discrete process as it can be broken down into discrete classical errors (bit flips) and discreet quantum errors (phase flips)⁴. If one were to encode the information of a single “logical” qubit across a larger block of multiple “physical” qubits, the qubits can essentially be cloned⁴. Instead of copying the exact state, the system spreads one logical qubit’s information across several entangled physical qubits, avoiding the no-cloning rule. With algorithms, such as Shor’s code (not to be confused with Shor’s algorithm), the system can continuously monitor these physical qubits for discrete bit and phase flips and systematically correct them, protecting the underlying logical state without ever actually measuring or cloning the delicate system⁴.

3.3 Excel at Some Tasks

Even when we reach a point where fault tolerant quantum computers have enough qubits to do real-world computations, they cannot replace classical computers. Quantum algorithms only provide a computational advantage over classical algorithms when the limiting factor of a problem lies strictly in the internal information processing, rather than in the reading of raw inputs⁴. For example, if a computer is tasked with reading huge volumes of raw files or unstructured inputs, the speed is fundamentally limited by the number of accesses to the input. In such scenarios, quantum computers offer no more than a polynomial advantage over their classical counterparts⁴. If reading the input inherently takes $O(n)$¹¹ time, quantum computers cannot bypass that physical limit. However, quantum computers excel at specialized mathematical problems, such as factorizing (large) primes, where they get their advantage because of the exponential number of states that can be checked simultaneously. Since a system of $n$ qubits exists in a simultaneous superposition of $2^n$ states, a single logical operation effectively acts on all those $2^n$ states at once. This is exponentially faster than classical computers, where $n$ bits can only represent exactly 1 state at any given moment and must evaluate possibilities sequentially. Because of this, classical computers will remain the standard for daily computing.

4. Real-World Applications

One of the most promising applications has to do with simulating quantum systems. Simulating the exact behavior of molecules for chemical engineering or drug discovery with classical computers is exceptionally difficult as the computational power and memory needed grow exponentially with each additional particle¹. Quantum computers, however, operate using the exact same quantum mechanical principles as the molecules they are attempting to simulate. Therefore they can naturally represent quantum systems of interest, which makes them the ideal for modeling complex chemical reactions and advancing pharmaceutical research¹.

Quantum algorithms like Grover’s, Shor’s, and Deutsch’s drastically reduce computational complexity. Deutsch’s algorithm is primarily used as a conceptual proof of quantum advantage (the threshold where a quantum computer can perform a specific task faster or more efficiently than the best possible classical computer). It effectively determines whether a given mathematical function is constant (i.e. the function returns the same output for all inputs) or balanced (i.e. the function returns 0 for half of the inputs and 1 for the rest) using only a single query. A classical computer would instead always require two queries¹. Grover’s algorithm is much more practical, as it’s about speeding up searching unorganized databases. While the time complexity for searching through a database is $O(n)$, the time complexity for Grover’s algorithm is $O(\sqrt{n})$⁴.

Additionally, quantum mechanics has uses in cryptography. For encrypted information to be decrypted, the corresponding keys need to be exchanged. This is traditionally done through public key exchange, where private and public keys are generated, in the event the public key is intercepted by a malicious party when exchanging keys, no information about how to decrypt the encrypted message can be inferred. Such forms of encryption depend on the difficulty of factoring very large numbers. With a sufficiently powerful quantum computer, it’s very easy for Shor’s algorithm to factor such large numbers, essentially breaking all current forms of encryption. Whereas, Quantum Key Distribution (QKD) relies on the fragility of quantum states. If one were to attempt to intercept a quantum key transmitted via entangled photons, the act of “observing” collapses the quantum state¹². This would allow the communicating parties to recognize the interception, and discard the compromised keys before any sensitive data is transmitted¹².

5. Conclusion

We are currently in a transition period, between only having classical computers and making fully functional quantum computers in the future. Despite the significant, rapid hardware advancements, we are still in an era just before these machines become mainstream¹. This is primarily because the robust, large-scale quantum error correction necessary for fault tolerant quantum computers isn’t here yet¹. As successful solutions to combat decoherence are built, and scaled up (in terms of the number of qubits, proportional to the computational power), quantum computing will move out of the lab⁸. It’s important to understand that this doesn’t lead to the obsolescence of classical computers. Since quantum machines only excel when internal information processing, not raw data input, is the primary bottleneck, classical computers will remain the standard for everyday applications⁴. Ultimately, the future of quantum computing lies in acting as a specialized accelerator, complementing traditional processors (analogous to how GPU’s, or NPU’s complement CPU’s).

FURTHER READING:

• Einstein-Podolsky-Rosen (EPR) Paradox: Exploring the foundational debates on quantum entanglement.
• Turing Machines: The theoretical blueprint for classical computation.
• Logical Redstone: A creative way to visualize logic gates in Minecraft.
• Landauer’s Principle: The physical limits of computation and heat generation.
• J-coupling: The quantum mechanical interaction used in NMR multi-qubit logic.
• Wavefunction Collapse: Different interpretations and physical explanations of why superposition breaks down.
• Hamming Codes: Traditional methods for error correction in classical bits.
• Bell’s Theorem & Hidden Variables: Proving that quantum mechanics cannot be explained by hidden local variables.
• AlphaFold: How advanced computational models are already tackling biological folding, a space quantum computing aims to revolutionize.
• Public Key Encryption: Many forms of encryption currently used.
• The No-Cloning Theorem: The fundamental rule of quantum mechanics that prevents the creation of an identical copy of an arbitrary unknown quantum state (highly relevant to your error correction section).
• DiVincenzo’s Criteria: The theoretical checklist of conditions necessary for a physical system to function as a viable quantum computer.
• Post-Quantum Cryptography: How classical encryption methods and algorithms are currently being updated to resist future attacks by quantum computers running Shor’s algorithm.
• Quantum Supremacy / Quantum Advantage: Specific milestone experiments (such as Google’s 2019 Sycamore processor experiment) demonstrating a quantum computer solving a problem no classical computer practically could.
• Topological qubits: Work on topological qubits by Microsoft (in their Majorana 1 quantum computing processor). Topological qubits are another type of qubits.

Footnotes: