Qubit-Based Quantum Neuron Architectures

• Qubit-based quantum neurons are quantum computational blocks that encode weighted inputs and nonlinear activations onto qubit registers using controlled rotations, feature maps, or Hamiltonian evolution.
• They span diverse models—including gate-model perceptrons, phase-encoded neurons, Hopfield-style networks, and kernel machines—each designed for optimal hardware implementation and scalability.
• Experimental results and simulations highlight trade-offs in qubit count, circuit depth, and activation nonlinearity, informing the development of scalable quantum neural network architectures.

Searching arXiv for recent and foundational papers on qubit-based quantum neurons and closely related models. A qubit-based quantum neuron is a quantum computational primitive that maps neuron-like states, weighted combinations, and activation behavior onto qubit registers and quantum circuits. Across the literature, the term covers several distinct constructions: gate-model perceptrons based on overlap estimation (Tacchino et al., 2018), feed-forward architectures built from such neurons (Tacchino et al., 2019), phase-encoded neurons for continuous data (Mangini et al., 2020), Hopfield-style neurons implemented by multi-controlled rotations on NISQ hardware (Miller et al., 2021), kernel-based neurons with constant-depth parametrized circuits (Carvalho et al., 2022), RUS-based threshold neurons that encode activations in a single qubit (Cao et al., 2017), and Hamiltonian or analog perceptrons implemented with interacting qubits, including Rydberg platforms (Agarwal et al., 2024). A broader precursor is Burger’s “simulated qubit” neuron, which is classical in substrate but qubit-like in state representation and phase-sensitive interference (Burger, 2011). Taken together, these models define a research area in which the neuron is not merely a metaphor for a qubit, but a concrete circuit or dynamical block intended to reproduce some combination of weighted summation, nonlinear activation, probabilistic output, and composability into larger quantum neural networks.

1. Historical emergence and scope of the term

One early strand is Burger’s “simulated qubit,” a recurrent neuron configured as a multivibrator whose logical state is represented by a 2-dimensional vector, with high frequency corresponding to logical 1, low frequency to logical 0, and phase carrying sign information (Burger, 2011). Burger’s model already uses qubit language—basis states, superposition, phase, direct products, and Deutsch- and Grover-like procedures—even though it is explicitly classical and “less potent than the qubits of quantum physics” (Burger, 2011). This established an important conceptual distinction: “quantum neuron” can mean either a physical qubit implementing neural computation or a classical device reproducing qubit-like behavior.

In gate-model quantum computing, a more literal qubit-based neuron appears as a perceptron-like circuit operating on $N$ data qubits plus one ancilla, where classical binary vectors are encoded as equally weighted superpositions with $\pm 1$ phases (Tacchino et al., 2018). The overlap between input and weight states is converted into an ancilla activation probability, yielding a quantum analogue of a perceptron (Tacchino et al., 2018). This line was extended into a feed-forward quantum neural network implemented on superconducting hardware, where multiple such neurons were composed in either hybrid or fully coherent form (Tacchino et al., 2019).

A second major strand uses phase-encoded states for continuous inputs. In this formulation, a neuron processes an input vector of dimension $N=2^n$ using $n$ encoding qubits and one ancilla, with both input and weight encoded as locally maximally entanglable states whose amplitudes are uniform and whose information is carried by phases (Mangini et al., 2020). This construction generalizes earlier binary-input perceptrons to continuous inputs without increasing qubit count, enabling differentiable parametrizations compatible with gradient-based methods in principle (Mangini et al., 2020).

A third strand connects quantum neurons to associative memory and Hopfield dynamics. In a Quantum Hopfield Associative Memory, a “qubit-based quantum neuron” is a multi-controlled $R_y$ rotation acting on an ancilla, with angle $\phi_i$ derived from the classical Hopfield field $\theta_i=\sum_j w_{ij}x_j$ (Miller et al., 2021). This design was specifically adapted to present-day IBM hardware by removing mid-circuit measurement and reset (Miller et al., 2021).

More recent work frames quantum neurons as kernel machines. In this setting, the activation is the probability of an ancilla firing after a feature-map overlap computation, and different neuron families correspond to different quantum feature maps (Carvalho et al., 2022). A related 2025 optical model explicitly takes Mangini et al.’s qubit-based neuron as a starting point and proposes synthesis algorithms and an optical variant with reduced quantum resource requirements (Mehta et al., 23 Jul 2025).

2. Core mathematical formalisms

The simplest gate-model perceptron encodes binary input and weight vectors $\vec{i},\vec{w}\in\{-1,1\}^m$, with $m=2^N$, into quantum states

$$|\psi_i\rangle = \frac{1}{\sqrt{m}}\sum_{j=0}^{m-1} i_j |j\rangle,\qquad |\psi_w\rangle = \frac{1}{\sqrt{m}}\sum_{j=0}^{m-1} w_j |j\rangle,$$

so that

$\pm 1$0

A unitary $\pm 1$1 is chosen such that $\pm 1$2, and a multi-controlled NOT transfers the amplitude of $\pm 1$3 to an ancilla. The activation probability is then

$\pm 1$4

This provides a nonlinear classifier through measurement, but it is symmetric under $\pm 1$5 and $\pm 1$6, unlike a classical sign-based perceptron (Tacchino et al., 2018).

The continuous-input phase-encoded neuron replaces binary phase signs by continuous phases $\pm 1$7, defining

$\pm 1$8

Its activation is

$\pm 1$9

with the explicit form

$N=2^n$0

The nonlinearity arises from interference and the Born rule, and the continuous parametrization makes the model differentiable in the phase parameters (Mangini et al., 2020).

In the Hopfield-style neuron, a classical neuron state $N=2^n$1 is encoded into a qubit

$N=2^n$2

The classical field $N=2^n$3 is normalized to

$N=2^n$4

and the neuron applies $N=2^n$5 to an ancilla. For an ancilla initialized in $N=2^n$6, the activation is

$N=2^n$7

This is smoother than the earlier RUS-based activation of Cao et al., but it removes the need for mid-circuit measurement and reset (Miller et al., 2021).

A more explicitly neuron-like threshold mechanism appears in the RUS-based “Quantum Neuron” model. There, a scalar activation $N=2^n$8 is encoded in a single qubit by

$N=2^n$9

and a repeat-until-success map

$n$0

is iterated to approximate a hard threshold at $n$1. This allows a qubit to emulate a neuron with threshold activation while preserving coherence and entanglement (Cao et al., 2017).

Kernel-based neurons unify several of these ideas. A generic neuron prepares $n$2 and $n$3 from a feature map $n$4, computes $n$5, and uses a multi-controlled NOT to produce an ancilla activation with probability

$n$6

The neuron’s output is therefore a Bernoulli random variable whose mean depends on the chosen feature space mapping (Carvalho et al., 2022).

3. Encodings, activations, and the problem of nonlinearity

A central issue in all quantum neuron proposals is that a neuron requires a nonlinear activation, while closed quantum dynamics are linear. Different papers resolve this in different ways.

Measurement-based nonlinearity is the most common solution. In the binary perceptron model, the ancilla activation probability $n$7 is a quadratic function of the inner product, and the nonlinearity is supplied by the Born rule (Tacchino et al., 2018). The feed-forward network built from these neurons relies on ancilla measurement after each neuron in the hybrid mode, while the fully coherent version uses deferred measurement and partial trace to recover the same output statistics (Tacchino et al., 2019).

In the continuous phase-encoded neuron, the activation is again an overlap squared, now as a nonlinear trigonometric function of phase differences (Mangini et al., 2020). This makes the neuron capable of classifying linearly non-separable sets already at the single-neuron level, while retaining a differentiable parametrization (Mangini et al., 2020).

The RUS-based model addresses nonlinearity more directly. The map $n$8 has stable fixed points at $n$9 and $R_y$0 and an unstable fixed point at $R_y$1; iterating it sharpens a sigmoidal response into an approximate step (Cao et al., 2017). The paper gives expected runtime bounds for approximating the threshold map within error $R_y$2 (Cao et al., 2017).

A separate line of work focuses specifically on approximating the unit step function on quantum hardware. This amplitude-based implementation expands upon RUS protocols but modifies them so that only a single measurement is required, and demonstrates circuits with up to 8 qubits and up to 25 CX-gate applications on NISQ hardware (Koppe et al., 2022). This suggests a route to using step-like activations as reusable subroutines inside fully quantum neural networks (Koppe et al., 2022).

In Hamiltonian perceptrons, the activation comes from adiabatic or shortcut evolution under

$R_y$3

with output probability

$R_y$4

Here the neuron is a qubit whose excitation probability realizes a sigmoid-like activation, and the “weights” are coefficients in an Ising-type Hamiltonian that may include multi-qubit terms (Ban et al., 2021).

A different strategy is to make the quantum part linear and outsource nonlinearity to a classical post-processing layer. The duplication-free QNN uses an $R_y$5-qubit variational circuit to produce expectation values $R_y$6, then applies classical sigmoids

$R_y$7

and a linear output node. Each observable channel therefore functions as a “quantum neuron” without requiring multiple copies of the same state (Hou et al., 2021). This is universal in $R_y$8 without the duplication overhead of earlier universal QNN models (Hou et al., 2021).

4. Architectural families

Several broad architectural families can be distinguished.

4.1 Perceptron and feed-forward architectures

The perceptron-like models of Tacchino et al. use $R_y$9 qubits to encode an $\phi_i$0-dimensional input or weight vector and one ancilla to extract activation (Tacchino et al., 2018). This was extended to a feed-forward network implemented on IBMQ Poughkeepsie using up to 7 active qubits, with hidden neurons recognizing horizontal and vertical lines and an output neuron combining them (Tacchino et al., 2019). The fully coherent and hybrid versions are formally equivalent by deferred measurement, but differ in hardware demands (Tacchino et al., 2019).

The 2021 architecture-exploration study observes that different quantum neuron designs are complementary. VQC-based neurons support real-valued weights but are difficult to extend to multiple layers, while QuantumFlow neurons can build multi-layer networks efficiently but are limited to binary weights. By mixing these neuron types, the paper constructs QF-MixNN and reports 90.62% accuracy on MNIST, compared with 52.77% and 69.92% on VQC and QuantumFlow, respectively (Wang et al., 2021). This suggests that the term “qubit-based quantum neuron” does not denote a single canonical circuit, but a modular design space of qubit-level primitives (Wang et al., 2021).

4.2 Hopfield and associative-memory architectures

The QHAM model uses one qubit per neuron, plus one ancilla per update if reset is unavailable, and composes update blocks sequentially (Miller et al., 2021). The weights are trained classically by the Hebbian rule, but recall is quantum and measurement is deferred until the end (Miller et al., 2021). The network reproduces a stochastic version of asynchronous Hopfield dynamics, with the number of update steps treated as a hyperparameter rather than a convergence criterion (Miller et al., 2021).

The earlier RUS-based “Quantum Neuron” paper also constructs feedforward and Hopfield networks. It proves that qubit neurons can simulate classical feedforward and Hopfield networks with polynomial overhead, while also operating on superpositions of inputs (Cao et al., 2017). In numerical experiments, training on superpositions suffices to learn Boolean functions like XOR and 8-bit parity on all individual basis states (Cao et al., 2017).

4.3 Kernel-machine and constant-depth architectures

The kernel-based framework interprets a quantum neuron as a fully quantum kernel machine whose activation is the overlap squared between input and weight feature states (Carvalho et al., 2022). Within that framework, the proposed constant-depth quantum neuron uses $\phi_i$1 data qubits plus one ancilla and applies a tensor-product feature map with activation

$\phi_i$2

or, in the parametrized version,

$\phi_i$3

The circuit depth is constant in $\phi_i$4, and gate count scales linearly (Carvalho et al., 2022). By tuning $\phi_i$5 and $\phi_i$6, the activation shape can be made approximately linear, logarithmic, exponential-like, or non-monotonic (Carvalho et al., 2022).

4.4 Analog, Hamiltonian, and Rydberg architectures

In the multi-qubit-potential model, a neuron is a qubit whose potential

$\phi_i$7

feeds into an Ising-type Hamiltonian and a sigmoid activation (Ban et al., 2021). The addition of multi-qubit interactions enables one-neuron XOR and prime-search tasks and reduces network depth for CNOT, Toffoli, and Fredkin implementations (Ban et al., 2021).

The Rydberg quantum perceptron takes a related but hardware-oriented form. Its basic Hamiltonian is

$\phi_i$8

with a modified form including input drives (Agarwal et al., 2024). This can be mapped from the natural Rydberg Hamiltonian by appropriate choices of detuning and interaction strengths (Agarwal et al., 2024). The model extends to multiple output qubits for multi-class classification and is shown numerically to classify quantum phases and entanglement classes with high accuracy, including 95% accuracy in a noisy four-class entanglement task (Agarwal et al., 2024).

4.5 Optical variants

The optical extension of Mangini et al.’s qubit-based neuron represents inputs and weights as phase states over $\phi_i$9 qubits or, in the optical version, as single-photon superpositions over $\theta_i=\sum_j w_{ij}x_j$0 modes (Mehta et al., 23 Jul 2025). The neuron’s output is the squared magnitude of the overlap

$\theta_i=\sum_j w_{ij}x_j$1

Two qubit-circuit synthesis algorithms are proposed for the required diagonal unitary, and the optical realization reduces depth and width relative to the qubit version, using only linear optical elements in the single-photon subspace (Mehta et al., 23 Jul 2025).

5. Implementations, performance, and hardware evidence

The literature contains both simulations and experiments on actual hardware.

Tacchino et al. implemented a few-qubit perceptron on IBM Q 5 Tenerife. For $\theta_i=\sum_j w_{ij}x_j$2, the optimized hypergraph-based implementation yielded activation probabilities clearly separated into two bands: $\theta_i=\sum_j w_{ij}x_j$3 for positive patterns and $\theta_i=\sum_j w_{ij}x_j$4 for others (Tacchino et al., 2018). The same authors later implemented a feed-forward network on IBMQ Poughkeepsie using up to 7 active qubits and showed correct classification of line vs non-line $\theta_i=\sum_j w_{ij}x_j$5 patterns in both hybrid and coherent modes after error mitigation (Tacchino et al., 2019).

The continuous-input neuron of Mangini et al. was demonstrated on IBM Q Yorktown for image-recognition tasks, and the paper reports $\theta_i=\sum_j w_{ij}x_j$6 accuracy on distinguishing “0” vs “1” MNIST digits using a single 10-qubit neuron with a fixed template and threshold $\theta_i=\sum_j w_{ij}x_j$7 (Mangini et al., 2020).

The QHAM was implemented in simulation and on IBM hardware. On noiseless simulations for $\theta_i=\sum_j w_{ij}x_j$8, $\theta_i=\sum_j w_{ij}x_j$9, and $\vec{i},\vec{w}\in\{-1,1\}^m$0, majority-vote accuracy can be near perfect for $\vec{i},\vec{w}\in\{-1,1\}^m$1, and density accuracy is typically beyond 90% (Miller et al., 2021). On actual ibmq_16_melbourne hardware for $\vec{i},\vec{w}\in\{-1,1\}^m$2, $\vec{i},\vec{w}\in\{-1,1\}^m$3, and $\vec{i},\vec{w}\in\{-1,1\}^m$4, majority-vote accuracy drops substantially because limited connectivity introduces additional SWAPs and routing qubits not captured fully by calibrated noise models (Miller et al., 2021).

The constant-depth kernel-based neuron was validated on a Qiskit simulator. On six toy problems, the parametrized constant-depth neuron achieved AUC ROC values of 1.0 on all but the outer-circle task, where it reached 0.9524 (Carvalho et al., 2022). On handwritten digit recognition with the scikit-learn digits dataset, PCDQN consistently outperformed CVQN, CDQN, and discrete-activation baselines, with a particularly large gain for digit 1, where AUC ROC rose to 0.9444 (Carvalho et al., 2022).

The duplication-free QNN was benchmarked against QCL and CCQ. On a 2D donut classification problem, DQNN reached 97.63% accuracy with 2 qubits and one copy, while CCQ required more qubits and copies yet remained below 83% (Hou et al., 2021). On a synthetic 2D polynomial regression task, DQNN achieved 4.29% mean relative error (Hou et al., 2021). On a quantum phase-recognition task for symmetry-protected topological phases, a 15-qubit DQNN reached 99.10% test accuracy (Hou et al., 2021).

The architecture-mixing study reports that mixed-neuron architectures can outperform either constituent family alone, reaching 90.62% accuracy on MNIST compared with 52.77% on VQC and 69.92% on QuantumFlow (Wang et al., 2021).

The amplitude-based unit-step implementation reports reliable experimental data with high precision from circuits involving up to 8 qubits and up to 25 CX-gate applications, enabled by hardware optimization and measurement error mitigation (Koppe et al., 2022). Although it is not itself a full neuron model, it directly addresses the activation bottleneck in qubit-based quantum neurons (Koppe et al., 2022).

6. Conceptual issues, misconceptions, and limitations

A recurring misconception is that any qubit used in a quantum machine learning circuit is automatically a “quantum neuron.” The literature does not support that usage. In most of these papers, a neuron is a structured module with a specific semantic role: weighted aggregation, activation, and reuse as a building block (Tacchino et al., 2018, Cao et al., 2017, Miller et al., 2021, Carvalho et al., 2022). A bare variational qubit without this semantics is not usually called a neuron.

A second misconception is that all quantum neurons are fully quantum analogues of classical neurons. Some are only partially so. The duplication-free QNN achieves universality by keeping the quantum part linear and placing the sigmoid in a classical processor (Hou et al., 2021). This suggests that “quantum neuron” can mean a hybrid object whose effective nonlinearity is classical, provided the quantum subroutine is the essential feature extractor (Hou et al., 2021).

A third misconception is that qubit-based quantum neurons uniformly promise exponential speedup. The evidence is mixed and architecture-dependent. The early perceptron papers stress exponential advantage in encoding resources, since $\vec{i},\vec{w}\in\{-1,1\}^m$5 features can be encoded in $\vec{i},\vec{w}\in\{-1,1\}^m$6 qubits (Tacchino et al., 2018, Tacchino et al., 2019). However, several papers also emphasize that arbitrary state preparation or diagonal synthesis can still be exponentially expensive in gates (Tacchino et al., 2018, Mehta et al., 23 Jul 2025). The constant-depth neuron avoids this particular bottleneck by using qubit-local tensor-product feature maps rather than arbitrary amplitude encoding (Carvalho et al., 2022).

The distinction between genuine quantum and quantum-inspired models is also important. Burger’s multivibrator neuron uses a 2D vector space, superposition-like states, and interference-like transformations, but it has no genuine entanglement, no unitarity constraint, and cheap repeatable measurement (Burger, 2011). It is therefore a useful conceptual precursor rather than a physical qubit neuron in the quantum-computing sense (Burger, 2011).

Finally, many proposals remain limited in scale or learning sophistication. Several models use hand-chosen weights or grid/random search rather than end-to-end scalable training (Tacchino et al., 2018, Tacchino et al., 2019, Carvalho et al., 2022). Others have only been demonstrated on simulators or on very small hardware instances (Miller et al., 2021, Koppe et al., 2022). This suggests that the field is still at the stage of exploring neuron primitives and architectural trade-offs rather than converging on a mature standard design.

7. Outlook and synthesis

Across the literature, a qubit-based quantum neuron is best understood as a family of qubit-level computational blocks rather than a single fixed object. The most common invariant across these constructions is the use of a qubit or small qubit register to encode neuron state, another mechanism—often overlap, controlled rotation, or Hamiltonian evolution—to encode weighted combinations, and a measurement- or dynamics-induced rule to produce a nonlinear or effectively nonlinear output (Tacchino et al., 2018, Cao et al., 2017, Miller et al., 2021, Carvalho et al., 2022).

One major design axis is the encoding of input and weight: binary phase signs (Tacchino et al., 2018), continuous phases (Mangini et al., 2020), Hopfield-style angle encodings (Miller et al., 2021), tensor-product local features (Carvalho et al., 2022), amplitude encodings with classical sigmoid heads (Hou et al., 2021), or analog spin interactions (Ban et al., 2021, Agarwal et al., 2024). A second axis is the source of nonlinearity: Born-rule measurement (Tacchino et al., 2018, Mangini et al., 2020), repeat-until-success maps (Cao et al., 2017, Koppe et al., 2022), probabilistic majority vote (Miller et al., 2021), classical post-processing (Hou et al., 2021), or analog excitation probabilities under Hamiltonian evolution (Ban et al., 2021, Agarwal et al., 2024). A third axis is the physical substrate: superconducting gate-model devices (Tacchino et al., 2018, Tacchino et al., 2019, Miller et al., 2021), photonic circuits (Mehta et al., 23 Jul 2025), Rydberg atom arrays (Agarwal et al., 2024), or even classical oscillatory circuits used in a qubit-like formalism (Burger, 2011).

This diversity suggests a plausible implication: the field is not converging on a single “correct” quantum neuron, but rather on a design language in which different neuron constructions trade off qubit count, depth, trainability, activation sharpness, encoding power, and hardware compatibility. The constant-depth kernel neuron prioritizes NISQ feasibility (Carvalho et al., 2022); the QHAM neuron prioritizes direct deployment on IBM hardware without mid-circuit measurement (Miller et al., 2021); the RUS neuron prioritizes threshold-faithful activation (Cao et al., 2017); the duplication-free neuron prioritizes universality without copy overhead (Hou et al., 2021); and the Rydberg perceptron prioritizes analog scalability and physically natural interactions (Agarwal et al., 2024).

A qubit-based quantum neuron is therefore not merely a quantum version of a classical perceptron. It is a research program aimed at identifying the smallest qubit-level module that can play the role of a neuron while still exploiting quantum state spaces, quantum interference, and hardware-native operations. Whether the dominant future form is gate-based, analog, hybrid, or photonic remains unsettled, but the existing literature already establishes the term as a technically precise object with multiple rigorous instantiations rather than a loose metaphor (Tacchino et al., 2018, Mangini et al., 2020, Miller et al., 2021, Carvalho et al., 2022, Agarwal et al., 2024, Mehta et al., 23 Jul 2025).