What is Quantum Reservoir Computing
A gentle path from static quantum feature maps to temporal quantum reservoirs.
Introduction
The easiest way to understand quantum reservoir computing is to begin with a simpler idea: use a quantum system as a feature maker.
A feature is a useful description of data, such as a frequency, an average, or a measured coordinate.
A fixed quantum system transforms the input and measurements become the new feature vector.
The classical readout learns how to combine the measured features for the task.
QRC is the same idea, but the quantum state is reused so features can contain recent history.
Think of the quantum system like a strange optical prism. A prism does not decide what the object is. It changes how light is spread out, so details that were hidden can become easier to inspect. In the same spirit, a quantum feature map does not need to be the final decision maker. It can reshape the input into measurement numbers that a simple classical model can use.
In this view, the quantum part is not the whole model. It is a fixed transformation. Data goes in, the quantum system produces measurement features, and a small classical readout learns how to use those features.
The quantum system creates coordinates. The readout learns what those coordinates mean for the task. This separation is the main reason the idea is approachable: we do not have to train every internal quantum interaction to understand the basic workflow.
This page builds the idea slowly. We first look at Quantum Extreme Learning Machines, where each input is transformed once. Then we add time and memory, which turns the same readout principle into quantum reservoir computing.
The path is deliberately staged. If the data points are independent, the static QELM picture is the cleanest starting point. If the data arrives as a sequence, the QRC picture adds one missing ingredient: the quantum state is reused, so the current feature vector can carry a trace of what came before.
Keep one sentence in mind: QELM is a static quantum feature transformation, while QRC is a quantum feature transformation that also carries temporal state.
Do not try to understand QRC first. First understand the static pipeline: input, fixed transformation, measured features, trained readout. QRC only adds state reuse over time.
We have separated the big idea into two parts: a fixed feature maker and a trained readout. Next we slow down and define what a feature map is before making it quantum.
Why Feature Maps?
Many learning problems become easier after we change how the data is represented. The original input may be hard to separate with a line, but a transformed version can expose useful structure.
This is not a quantum-specific trick. It is a general learning idea. A raw image is often transformed into edges and textures. A sentence is transformed into embeddings. A sound wave may be transformed into frequency features. The point is always the same: choose coordinates where the useful pattern is easier to express.
A sound clip is a long list of pressure values over time. That raw list is hard to classify directly.
We compute features such as average loudness, dominant frequency, and how quickly the sound changes.
A simple model can now combine those few descriptions to decide whether the sound is calm or sharp.
Quantum features follow the same logic. The difference is only how the new descriptions are produced.
A feature map is just a transformation:
Take the original description and rewrite it as a new description . Nothing has been classified yet. We have only changed how the data is represented.
The vector is the original input. The vector is the new representation. After that transformation, we often use a very simple readout:
Multiply each feature by a learned weight, add the results, then add a bias. The readout is simple; the feature map is what made the coordinates useful.
The readout is linear, but the features can be rich. That is the trick. Instead of training a large complicated model everywhere, we keep the feature maker fixed and train only the final layer.
A linear readout can only add weighted coordinates. It cannot invent complex geometry by itself. The feature map does the geometric work first. After that, the readout only has to learn which measured coordinates should count positively, negatively, or barely at all.
could mean two simple descriptors of a signal.
A fixed map turns that input into measured features, for example .
The readout computes and learns the weights from examples.
The numbers are illustrative. The structure is the important part: the feature map creates coordinates, then the trained readout combines them.
In real training, the data chooses the weights. Here the numbers only make the mechanics visible.
The sketch below shows the same idea geometrically. The labels do not change; only the coordinate system changes, making a simple linear boundary more useful.
At this stage, only the readout weights are trained. The feature map can be fixed. This simple separation will carry directly into QELM and QRC.
A feature map changes the coordinate system. A linear readout then combines those coordinates. Quantum feature maps use a quantum system to create the coordinates, but the learning logic is the same.
Quantum Extreme Learning Machines
A Quantum Extreme Learning Machine, or QELM, applies this feature-map idea with a quantum system. The word “extreme” comes from classical extreme learning machines: the hidden layer is fixed, and only the output layer is trained.
QELM means: use a quantum system as the fixed hidden layer, measure what comes out, and train a classical output layer on top.
That last sentence is the whole mental model. A QELM does not try to tune the quantum system for every task. Instead, it treats the quantum system as a fixed, expressive hidden layer. The training problem is pushed to the classical readout, where ordinary regression or classification tools are stable and cheap.
In a QELM, the hidden layer is quantum. You encode an input into a quantum circuit or quantum system, let it transform the input, measure observables, and train a classical readout on those measured values.
Put the input values into controllable parameters, such as rotation angles or drive amplitudes.
Let the fixed quantum circuit or fixed physical dynamics mix the encoded information.
Read out selected observables and turn those measurement averages into a feature vector.
Train only a classical linear readout on top of those features.
The important point is that this is static. One input goes in. One feature vector comes out. The quantum system is not remembering a previous input.
If the first example is a red point and the second example is a green point, the second feature vector should not depend on the first example. Each data point receives the same fixed transformation recipe. That is exactly what you want for many ordinary classification or regression datasets.
A small pattern is encoded as .
The same circuit or quantum dynamics are used for every training example.
Measurements give ; a linear readout turns them into a score such as .
After this input is processed, the next input starts from the same fixed recipe. That is why QELM is static.
The raw input is .
The fixed quantum recipe transforms the input into a state .
We estimate .
The trained readout returns a score, for example .
Nothing in this story depends on the previous data point. That is the static QELM assumption.
Read the diagram left to right. The quantum block is fixed; the trainable part is only the small readout block at the end.
If you can say “one input creates one feature vector, independently of the previous input,” you have the core QELM picture.
QELM is the first quantum version of the feature-map idea. It is powerful but still static: the feature vector describes the current input, not a history.
Static Quantum Features
Let the input be . A fixed quantum map prepares a state that depends on that input. We do not need to specify the full circuit here. Conceptually, it creates a state:
After the input has gone through the fixed quantum recipe, the quantum system is in a state that depends on that input.
Read as “the quantum state after the input has been encoded and transformed.” The page does not need the full machinery of density matrices yet. For now, the important part is simply that the state depends on the input.
Then we measure a small list of observables. These measurements become the feature vector:
Measure several chosen quantities. Each measurement average becomes one coordinate of the feature vector .
Each entry in this vector is one measured summary of the quantum state. One observable might capture one kind of correlation, another observable might capture a different kind of population imbalance, and another might respond strongly only when two parts of the system interact. Together they form a richer coordinate system than the raw input.
Suppose one observable returns in 68 shots and in 32 shots.
The estimated feature is .
Doing this for gives a vector such as .
This is why the page writes features as expectation values. They summarize repeated measurement statistics, not a single magical readout.
The trained part is still only the readout:
This makes QELM easy to reason about. The quantum system is a fixed feature generator. The classical readout learns how to combine those features for classification or regression.
The readout does not need to know how the quantum dynamics produced every feature. It only needs a table of feature vectors and target labels. This is why QELM is often a good baseline: it tells us how much can already be achieved by static quantum features before adding temporal memory.
For this page, read an expectation value as a measured average. It is one number extracted from many repeated measurements of the transformed quantum state.
Static quantum features are measurement summaries of a fixed quantum transformation. They become the inputs to the classical readout.
Linear Separation
Suppose two classes are mixed together in the original input space. A linear model may fail because no straight boundary separates them well.
For example, imagine two kinds of sensor signal. In the raw coordinates, one axis might be average amplitude and the other axis might be average frequency. Those two numbers may not be enough: the two classes overlap because the important distinction is hidden in a more subtle pattern.
A good feature map bends the representation without making the readout complicated. After the quantum transformation, the same classes may be separated by a simple linear boundary in feature space.
The phrase “linear separation” can sound abstract, but the picture is simple. We are not changing the labels. Red examples stay red and green examples stay green. We are only changing the coordinate system in which the readout sees them.
This is the first mental model for QELM: the quantum system does not directly make the final decision. It creates coordinates where the final decision is easier.
Imagine two signal types curled around each other. A straight line cuts through both groups, so a linear model is confused.
The quantum features spread the same examples into new coordinates. Now one simple line can separate most red points from most green points.
This makes the topic feel mysterious and too large. It suggests the quantum device must directly know the task.
The quantum part creates useful measured coordinates. The classical readout learns the task-specific combination.
The fixed quantum map is more like a complicated lens. It can reveal useful structure, but the task-specific decision still belongs to the readout. This keeps the training story clean and gives us a fair way to compare static feature maps against temporal reservoirs later.
The quantum system does the representation work. The linear readout does the task-specific learning.
Is the task really temporal, or can independent static quantum features already solve much of it? This question is why QELM is an important baseline.
Linear separation explains why a fixed feature map can be useful. It does not yet explain memory. Memory enters only when we stop resetting the system between inputs.
From Static to Time
QELM is useful, but it does not automatically model time. If you give it one input, it returns one transformed feature vector. If you give it the next input, it starts again.
We still measure features and train a simple classical readout.
The next input should be processed in the context left by previous inputs.
The reservoir state becomes the carrier of short-term memory.
Starting again is not a bug. For independent data points it is exactly what we want. But it becomes a limitation when the meaning of the current input depends on what happened just before it.
Many real tasks are not like that. A signal, a sensor stream, a financial series, or a chaotic system depends on what happened before. The current value often makes sense only together with recent history.
Consider a sequence . The value alone tells us something, but the short history tells us more: the signal rose and then slightly fell. A static feature map that sees only cannot directly know that local trend.
To handle that, we need one extra ingredient: a state that is reused over time. That is where reservoir computing enters.
Process , measure , then process independently. The second feature vector does not know what the first input was.
Process , keep the resulting state, then inject into that state. The second feature vector can now contain traces of both inputs.
QELM asks, “What features does this input produce?” QRC asks, “What features does the current reservoir state produce after seeing this input and recent previous inputs?”
Compare the two rows. In QELM, each input is processed independently. In QRC, the state loops forward, so the next feature vector can carry context.
If you remember only one sentence here, use this: QRC is QELM-like feature generation plus a state that is carried forward in time.
We have crossed from independent examples to sequences. The next section gives that sequence idea a compact state-update formula.
Quantum Reservoir Computing
Quantum reservoir computing keeps the readout idea from QELM, but changes the feature maker from static to temporal.
A new value arrives, such as the next point in a signal.
The reservoir does not start from zero; it starts from what the previous inputs left behind.
The measured features now describe a history-aware state.
The quantum system is now used more like a dynamical medium than a one-shot feature map. Each new input nudges the current state. The state responds according to its own fixed quantum dynamics, and then we measure features from the resulting state.
Instead of preparing a completely fresh feature map for each input, the quantum system has a state at time . The new input updates that state:
The new reservoir state equals the result of applying the fixed update rule to the old state and the new input.
means what the reservoir currently remembers. is the new incoming value. is the fixed update rule: encode the new input, let the quantum system evolve, and produce the next state .
Here is the input at the current time step. The previous state carries recent history. The fixed update rule is the quantum evolution plus input injection.
The word “fixed” is important. The internal quantum dynamics are not usually trained by backpropagation through every time step. Instead, the reservoir provides a rich stream of temporal features, and the classical readout learns how to combine them.
After the update, we measure features:
The feature vector at time is made from measurements of the current reservoir state. Because the state was reused, those features can contain recent history.
And again, the trained part is only a simple readout. The difference is that can now contain information about the recent past, not only the current input.
This memory should be useful but not permanent. Very recent inputs should often matter more than very old inputs. This is the idea of fading memory: the reservoir carries context forward, but old context gradually loses influence so the system remains stable.
QRC does not need to remember every old input exactly. It needs a useful trace of recent history, shaped by the reservoir dynamics and readable through measurements.
QRC turns a fixed quantum feature maker into a temporal feature maker. The readout is still simple, but the measured features now come from a state that has memory.
A Simple Prediction Task
Imagine a time series:
A next-step prediction task asks: after seeing values up to time , what should come next? The target is not the current value. The target is the future value .
The reservoir state starts forming a trace of the signal.
The state changes again. It now reflects that the signal rose.
The state reflects the current value plus the recent rise-and-drop context.
The readout uses measured features from that state to estimate what comes next.
This is the key beginner intuition: QRC does not only see the latest value; it sees the latest value through a state shaped by recent values.
At every time step, the quantum reservoir receives the next value. Its state changes. We measure a feature vector and ask a linear readout to predict the next value:
Use the measurements available now to predict the next value. The readout learns which measured temporal features are useful for that prediction.
Read this formula from right to left. The reservoir measurements are the evidence available now. The weights say which pieces of evidence tend to matter. The bias shifts the final prediction up or down.
The reservoir is useful because is not just a transformed version of. It is a transformed version of the current input together with a fading trace of earlier inputs.
In the toy sequence , a static map would only transform the last value if we gave it only . A reservoir can transform the last value while still being influenced by the rise from to and the drop from to .
That is the core reason QRC is a temporal model. The state is reused, so the system can remember enough context for prediction without training the quantum dynamics themselves.
The new value updates the old reservoir state .
The measured vector now reflects the current input and traces of earlier inputs.
The readout uses to estimate the next value.
The reservoir does not need to store the whole past exactly. It only needs a useful fading trace for the prediction task.
The important loop is the green feedback arrow. It means the reservoir state after this step becomes the previous state for the next step.
The readout is trained so that features at time predict the next value . The reservoir creates the features; the readout learns the prediction.
Prediction is where the temporal nature becomes practical. The model uses a history-aware feature vector now to estimate a future value.
QELM vs QRC
QELM and QRC share the same learning philosophy: keep the quantum part fixed, measure features, and train a classical readout.
The difference is memory. QELM is a static feature map. QRC is a temporal feature map with state reuse.
This comparison matters scientifically. If a QRC model performs well, we should ask whether the gain came from quantum feature expansion alone or from the temporal reservoir state. A static QELM baseline helps separate those two explanations.
QELM tests the value of quantum features. QRC tests the value of quantum features plus temporal memory. A careful comparison needs both.
If a task has no meaningful temporal structure, QRC may not be the right explanation for a gain. If the task depends on history, QRC can add something that static QELM cannot.
QELM and QRC share a readout philosophy. The difference is whether measured features describe one input or a state shaped by an input history.
What to Remember
Start with QELM: input goes into a fixed quantum feature map, measurements become features, and a linear readout learns the output.
This already captures a useful pattern: the quantum system can be valuable even when it is not trained internally. It can act as a high-dimensional, nonlinear feature generator. For independent examples, that may be the right model to use.
Then add time: the quantum state is not reset after every input. It evolves from one step to the next, so measurements can reflect recent history. That is quantum reservoir computing.
This is the extra step that makes QRC different. The feature vector is no longer only about the current input. It is about the current input as seen through a state that has been shaped by previous inputs. That is why QRC belongs naturally to forecasting and sequence-processing tasks.
The simplest summary is:
Change the representation so a simple readout can work.
Use a fixed quantum system as a static feature map for independent examples.
Reuse the quantum state so measured features can carry recent history.
If examples are independent, start with the QELM picture. If order matters, if trends matter, or if the current value only makes sense in context, move to the QRC picture. The readout idea stays the same; the feature maker gains memory.
If someone asks for the difference in one sentence, answer: QELM maps a single input to quantum features; QRC maps a recent input history to quantum features through a reused quantum state.
Once this distinction is clear, the more technical pages on measurement, classical reservoirs, and physical implementations become much easier to read.